Clayr Madeira

Enviando email com Log4Net

2011-10-27T16:56:00.000-07:00

Continuando a seqüência de publicações sobre o framework Log4Net, vamos mostrar a configuração necessária para que o Log4Net envie mensagens de email com a mensagem da aplicação. Vamos usar o projeto inicial que pode ser baixado aqui.

Abrindo o arquivo web.config vamos mudar nossa chave do Log4Net acrescentando a configuração da conta de email que vai enviar e receber as mensagens. Lembrando que com essa framework é possível ter varias configurações, possibilitando salvar o arquivo em disco e enviar email simultaneamente.

Vamos deixar nossa chave da seguinte forma:

appender>

layout>

appender>

layout>

appender>

<root>

<appender-ref ref="A2" />

root>

<appender-ref ref="RollingFile"/>

logger>

<appender-ref ref="SmtpAppender"/>

logger>

log4net>

Acima temos a configuração mista, ou seja, para salvar em arquivo, mostrar no trace e enviar email. Inicialmente o projeto estava chamando sempre para salvar em arquivo:

private log4net.ILog logger;

protected void Page_Load(object sender, EventArgs e)

{

//Vamos usar o logger LogInFile, que salva todos os tipos de erro

logger = log4net.LogManager.GetLogger("LogInFile");

logger.Error("Lança a mensagem de error");

}

No método GetLogger nos pedimos para usar a configuração para salvar em arquivo. Basta fazer a modificação para chamar a configuração do e-mail:

logger = log4net.LogManager.GetLogger("LogInEmail");

logger.Error("Lança a mensagem de error");

Uma boa idéia seria usar para enviar email somente quando acontecesse erros não tratados, para isso, basta colocar dentro do Global.asax no método Application_Error.

Basta pegar a exceção lançada e passar a mensagem de erro para enviar:

private log4net.ILog logger;

protected void Application_Error(object sender, EventArgs e)

{

Exception exc = Context.Error;

if (exc is HttpUnhandledException)

{

exc = Context.Error.InnerException;

logger = log4net.LogManager.GetLogger("LogInEmail ");

logger.Error(exc.Message);

}

Agora o colocar esse tratamento de erro numa classe especializada, gerar uma DLL que possa ser usada em qualquer aplicação sua.

Lançando Mensagens para o Output do Visual Studio com Log4Net

2011-08-16T19:40:00.000-07:00

O Log4Net é um framework que permite à aplicação salvar log de diversas formas diferentes, sendo ele de erro ou não. Sua implementação é bastante simples, como já mostrado em outras publicações do blog.

Uma funcionalidade pouco conhecida no Log4Net é a possibilidade de lançar mensagens no momento do debug da sua aplicação, essas mensagens podem ser quando entrou em uma rotina extensa, quando deseja ver todas as modificações que a variável sofreu dentro de um laço.

Para isso, você pode usar o projeto da publicação anterior sobre o tema Log4Net clicando aqui.

Vamos modificar o arquivo Web.config, modificando justamente a configuração referente ao Log4Net:

layout>

appender>

<root>

<appender-ref ref="A2" />

root>

log4net>

Colocando essa configuração, agora vamos para a página padrão e vamos fazer a chamada da seguinte forma:

private log4net.ILog logger;

protected void Page_Load(object sender, EventArgs e)

{

/*Nesse Overload do Método GetLogger é preciso colocar o tipo,

* no nosso caso será a propria classe onde está o código*/

logger = log4net.LogManager.GetLogger(typeof(_Default));

logger.Debug("Lança a mensagem no nivel de debug");

}

Essas mensagens são lançadas dentro da janela de Output do Visual Studio, se não tiver o Output aberto vá ao menu View e selecione.

E nossa saída será exatamente essa:

Código do Projeto

Operador yield no Preenchimento de Coleções

2011-08-15T06:45:00.000-07:00

O operador yield existe desde o framework 2.0 e até hoje é um pouco desconhecidos entre os desenvolvedores C#. Sua utilização é basicamente nos métodos que retornam tipos IEnumerable sendo genérico ou não, ajudando no preenchimento das coleções de forma rápida e economizando recurso.

Utilizando o yield, você não precisa criar uma lista para preenchimento e depois retorná-la.

Você pode preencher uma coleção criando uma variável no método e adicionando valor a ela dentro do loop:

private List<Int32> retornaColecaoInteiros()

{

List<Int32> minhaLista = new List<int>();

for (int i = 0; i < 10; i++)

{

minhaLista.Add(i);

}

return minhaLista;

}

Ou simplesmente com a ajuda do yield preencher sua coleção, podendo ser generico ou não:

private IEnumerable<Int32> retornaColecaoInteiros()

{

for (int i = 0; i < 10; i++)

yield return i;

}

private IEnumerable retornaColecaoInteiros()

{

for (int i = 0; i < 10; i++)

yield return i;

}

O modo genérico do IEnumerable permiti você retornar uma coleção de qualquer tipo, de qualquer objeto.

Classe base:

public class Table

{

public String Descricao { get; set; }

}

Preenchendo com yield:

///

/// Preenche a Coleção de Tabelas

///

private IEnumerable<Table> fillTables(Int32 quantidade)

{

for (int i = 0; i < quantidade; i++)

{

Table tables = new Table();

tables.Descricao = "MinhaTabela " + i.ToString() ;

yield return tables;

}

Salvando Erros da Aplicação com Log4Net

2011-08-12T05:27:00.000-07:00

Habitualmente aplicações precisam salvar os erros que foram gerados, isso ajuda a encontrar a origem do erro. Dessa forma a solução para o problema vem muito mais rápida. Esses erros salvos em arquivos são chamados de Log.

Em aplicações .NET temos diversas maneiras de implementar uma rotina de Log da aplicação, existem frameworks próprias e você também pode gerar sua própria rotina de Log. Uma maneira simples de fazer isso na sua aplicação é usando o Log4Net, basta algumas configurações simples e esta pronto.

Primeiro é preciso baixar o Log4Net e adicionar como referencia na sua aplicação, clique aqui para efetuar o download da DLL.

Crie um novo projeto ou use um que já exista e adicione a referencia da DLL que acabou de baixar.

Após fazer isso, abra o Web.config e configure da tag configSections que será usado o Log4Net. Se não tiver a tag configSections e preciso criar:

configSections>

configuration>

Ainda dentro do configuration é preciso adicionar as configurações de onde será salvo o arquivo, o que será salvo no arquivo (error, warning, debug e etc), vamos colocar a configuração básica:

layout>

appender>

O nivel de log que será incluido no appender -->

<appender-ref ref="RollingFile"/>

logger>

log4net>

Na tag maximumFileSize será definido o tamanho que o arquivo deve atingir, quando ele chegar no tamanho máximo, será criado um novo arquivo.

Na tag appender podemos definir como vai ser salvo esse log. A framework da diversas opções para isso, podendo salvar em banco de dados como SQL Server, Oracle, DB2, SQLite e Microsoft Access, pode ser salvo em arquivo, email entre outras. Para informações de como implementar essas outras maneiras, acesse: http://logging.apache.org/log4net/release/config-examples.html

Precisamos colocar dentro do arquivo Global.asax, dentro do método Application Start que vamos usar a configuração do Log4Net, logo ficará dessa forma:

public class Global : System.Web.HttpApplication

{

void Application_Start(object sender, EventArgs e)

{

log4net.Config.XmlConfigurator.Configure();

}

void Application_End(object sender, EventArgs e)

{}

void Application_Error(object sender, EventArgs e)

{}

void Session_Start(object sender, EventArgs e)

{}

void Session_End(object sender, EventArgs e)

{}

}

Após essa configuração vamos exemplificar o uso, para isso vamos abrir a página padrão do nosso projeto e vamos implementar um método de exemplo para utilização do Log4Net.

private log4net.ILog logger;

protected void Page_Load(object sender, EventArgs e)

{

//Vamos usar o logger LogInFile, que salva todos os tipos de erro

logger = log4net.LogManager.GetLogger("LogInFile");

logger.Debug("Lança a mensagem no nivel de debug");

logger.Info("Lança a mensagem de info");

logger.Error("Lança a mensagem de error");

logger.Warn("Lança a mensagem de warning");

}

Ao executar o código, vamos ter o seguinte resultado:

Dentro da configuração no arquivo Web.config você pode configurar que só será salvo o que for lançado como erro, dessa forma:

<appender-ref ref="RollingFile"/>

logger>

Uma solução simples, porém é muito importante saber qual informação salvar para identificar o erro do usuário. Seria uma boa prática criar uma classe para salvar informações nesse arquivo, temos diversas maneiras de pegar informações desse erro, e do status da aplicação no momento que ocorreu o erro. Um exemplo de uma classe simples para manipular seria:

private log4net.ILog logger;

public void GravaError(Exception ex)

{

logger = log4net.LogManager.GetLogger("LogInFile");

StringBuilder buffer = new StringBuilder();

buffer.AppendFormat("{0}", ex.ToString());

if (ex.InnerException != null)

{

ex = ex.InnerException;

buffer.AppendFormat("\n {0}", ex.InnerException.ToString());

}

logger.Error(buffer.ToString());

}

Usando esse exemplo de classe, podemos usar o método GravaErro sempre que houver um erro, basta passar como parâmetro o erro que ele vai salvar no arquivo.

Código do projeto

Processos na Estratégia de Serviço

2011-08-11T06:02:00.000-07:00

Gerenciamento de Portfólio de Serviço

O termo portfólio, a nossa pasta de trabalho representa ao serviço que nos temos ou estamos fazendo.

Assim é preciso de um portfólio de serviço documentado para poder informar ao cliente o serviço que fornecemos ou que estamos planejando fornecer a ele. Dessa forma podemos maximizar o retorno sobre o investimento.

Na ITIL V3 o portfólio de serviços é um conjunto completo de serviços que são gerenciados pelo provedor de serviço, e é usado para gerenciar o ciclo de vida inteiro de todos os serviços. Ele é divido em três partes, são elas:

Funil de Serviço:

Mostra os serviços propostos para o futuro ou em desenvolvimento. A idéia desse funil é que todas as demandas sejam jogadas para dentro dele, mas só algumas vão sair desse funil e vão se transformar em um serviço operacional. Serve para priorizar o que a TI deve realmente desenvolver.

Catálogo de Serviço:

Contém todos os serviços que estão em produção sendo oferecidos atualmente ou estão sendo preparados para entrar em produção;

Serviços Obsoletos:

Serviços que não são mais oferecidos, que foram retirados do ambiente de produção porque não tem mais utilidade.

Neste processo de gerenciamento de portfólio de serviço temos quatro atividades que devemos seguir, são elas:

Definir:

Documentar tudo que pode ser disponibilizado para o cliente em forma de serviço, ou seja, tudo que está sendo entregue de serviço aos clientes e que também estão em desenvolvimento. Verificar se o caso de negocio está validada e completa para que possamos tomar as decisões corretas.

Analisar:

Maximizar valor do portfólio, alinhar, priorizar e balancear fornecimento e demanda. Onde será analisado o conjunto de serviços que temos no portfólio para saber o que devemos priorizar para justificar aonde usar o recurso que temos. Assim gerando o maior valor possível para o cliente.

Aprovar:

Finalizar portfólio proposto, aprovar serviços e recursos.

Formalizar:

Comunicação das decisões para saber aonde alocar os recursos e até mesmo contratar novos recursos.

Gerenciamento da Demanda

Objetivo de interpretar e influenciar a demanda do cliente por serviços, assim como fornecer capacidade para atender a estas demandas. Gerenciando corretamente, podemos evitar os riscos.

Podemos destacar que existem dois aspectos neste processo; tático (influencia a demanda) e estratégico (envolve a análise de padrões de atividades de negócio).

Os grandes problemas no gerenciamento da demanda são a capacidade insuficiente e a capacidade ociosa: A capacidade insuficiente impacta na qualidade dos serviços e limita o crescimento do serviço. Já a capacidade ociosa gera custos sem criar valor, porque é uma capacidade excessiva onde o excesso está inativo, o cliente pago por algo adicional que não se usa. Ninguém quer pagar por algo que não vai ser usado.

O gerenciamento da demanda será baseado em atividades do negocio, isso implica que, os processos do negocio como venda e contabilidade consomem serviço de TI para poder ser executados. Por isso a TI precisa entender muito bem como esses processos de negocio são influenciados pela TI, dessa forma conseguiremos manter sempre o negocio alinhando com a tecnologia da informação, para assim conseguir chegar aos seus objetivos.

Entendo o negocio podemos entender as demandas do serviço de TI e podemos assim conseguir prever as demandas para executar um processo do negocio. Por isso é muito importante para o gerenciamento de demanda ter acesso aos planos de negocio da empresa, aos seus objetivos futuros, para tentar prever qual serviço vai precisar para manter o crescimento da empresa.

O gerenciamento de demanda tem diversos benefícios, podemos destacar:

Serviços podem ser desenhados para atender aos padrões da demanda;
O catálogo de serviços pode ser melhor alinhado com os padrões de demanda. A TI pode liberar novos serviços para determinadas datas, porque analisou com antecedência os picos onde ela vai precisar mais da TI;
O gerenciamento de portfólio pode tomar decisões baseadas na demanda;
Os recursos na operação podem ser alocados para corresponder à expectativa de demanda (exemplo: número de atendentes x volume de chamadas);
Acordos de nível de serviço podem ser negociados com base na expectativa de demanda;
Incentivos ou penalidades podem ser aplicados para influenciar a demanda quando necessário.

O Gerenciamento Financeiro

Esse gerenciamento se aplica a todos os tipos de provedores de serviço, porque em qualquer organização questionam-se os custos dos serviços de TI, não importa se é provedor interno ou externo, porque o negocio que contratou a TI quer transparência.

Os objetivos desse processo são basicamente:

Assegurar que haja recursos financeiros para entrega de serviços de TI;
Fornecer ao negocio e à TI a quantificação, em termos financeiros, do valor dos ativos que sustentam o fornecimento de serviços e da qualificação das previsões operacionais;
Trabalhar em conjunto com o negocio e TI para identificar, documentar e acordar o valor dos serviços que estão sendo recebidos, e facilitar a modelagem e gerenciamento da demanda.

E temos varias razões para ter um gerenciamento financeiro, são eles:

Melhora a tomada de decisões porque fornece dados para priorizar as decisões de investimentos em TI. E ajuda a saber quanto custa desenvolver ou manter um novo serviço;
Proporciona uma avaliação de mudanças melhor e mais rápida, porque com informações a tomada de decisões será mais ágil;
Ajuda a gerenciar o portfólio de serviços, podemos extrair quais os serviços que custam mais, porque eles custam mais, além de saber os serviços a serem priorizados;
Assegura conformidade e controle financeiro;

Contabilidade de TI

É responsável por identificar os custos reais da entrega de serviços de TI, comparando estes custos com os custos que foram orçados e gerenciados a variação do orçamento. Quando decidimos aprovar um serviço no portfólio, naquele momento partimos de uma analise financeira do custo do serviço, da previsão da manutenção do serviço, com a contabilidade podemos confirmar se o que foi orçado é o custo atual para manter o serviço em operação.

Dentro da contabilidade de TI, tem alguns conceitos importantes a serem mencionados, são:

Registro de serviço: tudo que entra de custo precisa ser registrado e alocado ao serviço que pertence;
Tipos de custos: os custos podem ser categorizados, por exemplo: hardware, software, salários, administração, entre outros. Na hora de fazer o lançamento das despesas, pode ser categorizado;
Elementos de custos: é uma categorização intermediária. Custos de pessoal podem ser subdividos em: folha de pagamento, benefícios, gastos, treinamento, hora extra e outros.
Unidade de custo: é a menor categoria em que o custo pode ser alocado. Unidades de custos são coisas que podem ser contábeis (exemplo: horas trabalhadas, licenças de software, folhas impressas).
Classificação de custos: os custos ainda podem ser designados como sendo um custo capital (prédio, servidor e etc.) ou operacional (contrato de manutenção de servidor), custo direto (custos cobrados diretamente para um único serviço ou cliente) ou indireto (custos alocados em múltiplos serviços), custo fixo ou variável;

Riscos

Quando vamos colocar em pratica algumas estratégias que decidimos, temos que levar em consideração o risco, por isso precisamos ter um controle sobre os riscos associados.

Risco é definido como um resultado incerto, podendo ser um oportunidade positiva ou uma ameaça negativa.

Um exemplo fácil de assimilar seria o aumento da demanda por um determinado serviço, que pode ser uma ameaça ou uma oportunidade. Será uma oportunidade quando o provedor de serviços está preparado para atender a demanda. Se for um provedor externo, o aumento da demanda se converte e lucro porque o cliente vai pagar pelo excesso que eles vão consumir. E pode ser uma ameaça quando o provedor de serviços não está preparado, pois a sua capacidade pode ser insuficiente e o serviço começa a perder desempenho.

A ITIL recomenda usar um framework de gestão de riscos, onde esse framework compreenda a análise de riscos e o gerenciamento de riscos:

Análise de Riscos:

Identificar os riscos e seus proprietários;
Avaliar os riscos;
Especificar níveis de riscos aceitáveis e propor uma resposta;

Gerenciamento dos riscos

Implantar as respostas;
Obter garantia destas respostas;
Revisar periodicamente;

Estratégia do Serviço

2011-08-10T06:03:00.000-07:00

O nosso cliente não quer um serviço ou um produto, ele quer uma solução para resolver uma necessidade especifica.

Pensando dessa forma, precisamos saber qual será a melhor solução para o nosso cliente, porque o serviço serve como meio para que o cliente satisfaça a sua necessidade, logo precisamos saber o que ele necessita para prestar a melhor solução. A única forma de fazer isso é com recursos suficientes somado a boas habilidades para gerar valor ao serviço, entregando serviços adequados.

Para trabalhar com a estratégia é preciso entender a estratégia da organização para colocar o serviço disponível aos clientes, são eles:

Perspectiva:

Refere-se à visão e missão de uma organização, define seus valores e convicções, assim ela vai dar direção ao prestador de serviço. A partir do entendimento da missão do negócio, a TI vai procurar soluções que de alguma forma ajudem a organização a realizar a sua visão estratégica.

Posição:

Qual a imagem a empresa vai ter para seus concorrentes, como ela vai ser diferenciar deles, tratando assim da definição de serviço para um mercado especifico.

Plano:

A estratégia exige um plano de ação para que o provedor de serviço seja competitivo, serve para saber como vamos executar a estratégia.

Padrão:

Representam os procedimentos da organização, a padronização dos procedimentos e dos ideais para conseguir alcançar a missão, por exemplo, se o foco do prestador de serviço é ter um serviço de qualidade com preço baixo, ele não pode lançar no mercado uma idéia acima do preço dos concorrentes.

Matriz RACI

2011-08-02T08:00:00.000-07:00

A matriz RACI é um conceito que é utilizado no PMBOK e COBIT que a ITIL também adotou como melhores práticas, porque é uma ferramenta simples e útil para formalizar os papéis e responsabilidades durante um projeto.

Essa matriz serve para definir as responsabilidades e os papéis envolvidos no processo.

RACI é um acrônimo para Responsible, Accountable, Consulted e Informed. Ou seja, ela permite identificar quem é executor, responsável, consultado e informado para cada tarefa que precisar ser realizada.

Antes de fazer a matriz é preciso identificar os papéis envolvidos nas atividades, identificar os Accountable que terá por atividade, pois só pode ter um por tarefa.

Segundo o modelo RACI, podem ter quatro responsabilidades a serem delegadas, são elas:

Responsible: será cobrado pela execução da tarefa, garantindo que a tarefa foi feita;

Accountable: terá prioridade sobre a atividade e responde pelos resultados. Deve existir apenas um por processo;

Consulted: será consultado para fornecer conselhos e autorização em determinadas tarefas;

Informed: será informado sobre o progresso.

	Diretor	Gerente	Analista	Testador
Definição	C	R/A	I	I
Projetar	I	R/A	R	I
Desenvolver	I	R	A	I
Testar	I	R	I	A

No simples exemplo acima, foi construída uma matriz RACI com as responsabilidades de uma pequena equipe que vai desenvolver um novo produto de software.

Gerenciamento de Serviços segundo ITIL V3

2011-08-01T08:00:00.000-07:00

Atualmente a ITIL vem ganhando cada vez mais espaço e notoriedade no Brasil, ajudando a TI a ter uma base para o sucesso do gerenciamento dos serviços e isso se deve a preocupação em gerenciar cada vez mais e melhor a informação dentro das organizações e manter sempre o alinhamento das necessidades do negócio com a TI.

E aos poucos o que era novidade está se tornando padrão nas organizações, ou seja, quem insistir em se manter na bagunça tecnológica dos anos 90 não vai conseguir sobreviver no mercado competitivo de TI, pois os clientes estão mais exigentes e querem qualidade e retorno.

O Gerenciamento de Serviços de TI tem por objetivo prover serviços de TI com qualidade e alinhado às necessidades do negócio, buscando sempre fornecer valor para o cliente.

O serviço de TI é composto de recursos tecnológicos, tais como infraestrutura e aplicativos, e composto de habilidades dos envolvidos, como conhecimento, processos, gerencia e etc.. E podemos destacar como sendo o coração do gerenciamento de serviços, o ato de transformar recursos em serviços de valor para o cliente com a qualidade esperada, facilitando o resultado que o cliente quer alcançar.

Um bom indicador para o serviço seria um artefato com bom desempenho, redução de riscos, menor variação e no prazo esperado.

Para ter um melhor entendimento, e poder continuar com os estudos sobre ITIL V3 é necessário deixar claro alguns conceitos dentro do gerenciamento de serviços, são eles: funções, processos e papeis.

Funções

É um time ou grupo de pessoas especializadas e recursos necessários para realizar um ou mais processos ou atividades. Em uma organização maior, uma função pode ser quebrada em vários departamentos ou grupos. Entretanto, podemos também encontrar uma pessoa ou grupo desempenhando várias funções.

Exemplo de funções: Central de serviços, administração de redes, gerenciamento de aplicativos, gerenciamento de infraestrutura, administração de banco de dados.

Processos

É um conjunto de atividades coordenadas combinando e implantando recursos e habilidades com o objetivo de produzir uma saída, a qual, direta ou indiretamente, cria valor para um cliente ou parte interessada.

Todo processo tem uma entrada, uma seqüência de atividades para produzir algo e uma saída que é o resultado final do processo. Para cada atividade do processo pode existir procedimento e instruções de trabalho.

Uma boa documentação ajuda o processo a ser executado com consistência (ser repetido, sempre da mesma forma). É também aconselhável aplicar um feedback a partir da saída para avaliar se o processo atingiu a sua meta.

O processo pode ser medido na entrada, durante as atividades e na saída.

O processo tem quatro características:

- Tem resultado específico, ou seja, o sucesso ou insucesso são individualmente identificáveis;

- Deve ser orientado ao cliente, deve atender às expectativas do cliente seja ele interno ou externo;

- É mensurável: qualidade x custo, produtividade e desempenho das metas;

- O processo vai responder a um evento especifico, ao evento que iniciou o processo.

O processo tem um proprietário, e este é responsável por assegurar que o processo seja executado conforme acordado e documentado, e que atinja os objetivos propostos.

Esse papel é freqüentemente atribuído à mesma pessoa que executa o papel de gerente de processo, mas, os dois papéis podem estar separados em organizações maiores.

Papéis

São responsabilidades que uma pessoa ou um grupo tem em determinados processos, onde uma pessoa pode ter vários papeis. Então um papel não é cargo, eles podem estar relacionados a um cargo.

Na ITIL temos dois papeis importantes, o proprietário do serviço e o proprietário do processo:

O proprietário do serviço é responsável pelo contato direto com o cliente para tirar dúvidas em relação ao serviço, além de dar manutenção e suporte, ou seja, esse papel gerencia todo o ciclo de vida de um serviço.

O proprietário do processo é responsável por assegurar que o processo seja executado conforme acordado e documentado, além de fornecer recursos, realizar treinamento e melhorar o processo.

80% do aperfeiçoamento do gerenciamento da infraestrutura será proveniente da implantação de processos de Gerenciamento de Serviços de TI. Apenas 20% virá do aperfeiçoamento da tecnologia.

Fonte: Gartner – IT Service Management

Abaixo estou disponibilizando algumas perguntas encontradas na web e outras perguntas de simulas da ITIL V3 para se preparar para prova de certificação ITIL V3 foundation:

Simulado ITIL V3

Começando com ITIL V3

2011-07-29T04:26:00.000-07:00

Empresas nascem do mundo virtual cada vez com mais força, onde todo seu poder de venda e compra esta online. Consegue imaginar um site de compra coletiva, empresa aérea ou até mesmo operadora de cartão de crédito sem ajuda da informática para seu funcionamento? Eu também não!

Quando o negocio começou a ficar dependente da tecnologia da informação, a gestão da TI começou a ser mais questionada, mais cobrada em relação a qualidade e resultados, e assim a ITIL começou a ser mais difundida no mercado mundial.

Ela é a mais utilizada porque é um modelo não proprietário que pode ser usada em qualquer empresa e independe da tecnologia a ser usada e a sua prática pode ser aplicada em empresas privadas ou não, sendo aplicável a todos os tipos de organizações que prestam serviços de TI.

Muitas Pessoas acham que ITIL é uma metodologia de gestão, pensam que é uma receita de bolo onde tem um roteiro a ser seguido, mas na verdade não é bem assim, ela simplesmente é uma estrutura de boas e melhores práticas que já foram usadas no mercado com grandes e pequenas empresas para gerenciar o ciclo de vida de serviços de TI e deram certo, ou seja, são inovações de sucesso que foram testadas e validadas.

ITIL está muito ligada com o negocio, sempre preocupada com o alinhamento do negocio com o serviço de TI, para ter o melhor retorno possível com qualidade, e para isso ela propõe um ciclo de vida simples e completo para os serviços de tecnologia.

ITIL é o acrônimo de information Technology Infrastructure Library, em português seria Biblioteca de infraestrutura de TI. A versão 3 é a última versão e foi lançada em junho de 2007.

A nova versão do ITIL é composta por 5 livros: Estratégia de serviço, desenho de serviço, transição de serviço, operação de serviço e melhoria de serviço continuada.

Relação ISO/IEC 20000 e ITIL V3

A ITIL pode ser utilizada como base para empresas que querem adequar o seu sistema de gerenciamento de serviços de TI conforme requisitos da ISO/IEC 20000.

A ISO 20000 é baseada nas práticas da ITIL, quando uma empresa adota a ITIL fica fácil para ganhar a certificação ISO 20000, o mesmo ocorre com os profissionais que queiram tirar a certificação ISO/IEC 20000.

Vou fazer uma série com alguns resumos e detalhes sobre a ITIL até eu fazer a prova de certificação.

Abaixo estou disponibilizando algumas perguntas encontradas na web e outras perguntas de simulas da ITIL V3 para se preparar para prova de certificação ITIL V3 foundation:

Simulado ITIL V3

Desabilitanto BackSpace no ASP.NET com JavaScript

2011-07-28T19:17:00.000-07:00

Passei por uma situação que era precisava refatorar um método JavaScript que desabilitava o BackSpace dos campos para impedir que o navegador voltasse para a página anterior, porque também deveria abranger os campos marcados como somente leitura (readonly = true).

Busquei uma parte da solução na web, mas, tive que fazer algumas modificações para funcionar perfeitamente no ASP.NET:

function DesabilitaBackSpace() {

document.onkeypress = function (event) {

if (typeof window.event != 'undefined') {

event = window.event;

event.target = event.srcElement;

}

var kc = event.keyCode;

var tt = event.target.type;

if ((kc == 8)) {

if (tt == 'text' || tt == 'textarea') {

var readOnly = event.target.attributes.getNamedItem('readOnly');

if (readOnly != null) {

if (readOnly.value == 'readonly')

return false;

else

return true;

}

else

return true;

}

else

return false;

}

else

return true;

}

if (typeof window.event != 'undefined') // IE

document.onkeydown = document.onkeypress;

}

Melhor opção é colocar o código na MasterPage do projeto para ser utilizado em todas as páginas.

String.IsNullOrWhiteSpace() no Framework 4.0

2011-07-15T05:12:00.000-07:00

Quando precisamos fazer alguma validação com nossa variável String para saber se foi preenchida, ou seja, quando temos que garantir que não seja nula, que não esteja em branco e que não contenha um espaço vazio lá dentro, podemos utilizar o método da Framework 4.0, o String.IsNullOrWhiteSpace().

Em relação à desempenho esse método não é o perfeito, mas é bom. As chamadas a ao método resultará em uma pequena penalidade de desempenho. É simples, pratico e eficiente.

Bem, vamos ao porque do desempenho dele, mostrando o código da Framework 4.0 que faz nosso método IsNullOrWhiteSpace acontecer:

public static bool IsNullOrWhiteSpace(string value)

{

if (value != null)

{

for (int i = 0; i < value.Length; i++)

{

if (!char.IsWhiteSpace(value[i]))

{

return false;

}

return true;

}

Primeiro ele compara se é nulo e depois ele verifica todos os caracteres individualmente verificando se é nulo.

Lembrando que na linguagem C# os caracteres com espaço em branco pode ser codificado de algumas maneiras, como o \ n para novas linhas, \ r para retorno de carro ou até mesmo o \ v para tabulação verticais. No nosso exemplo, ficará mais claro:

class Program

{

static void Main(string[] args)

{

Console.WriteLine( String.IsNullOrWhiteSpace(" ") );

Console.WriteLine( String.IsNullOrWhiteSpace("\n") );

Console.WriteLine( String.IsNullOrWhiteSpace("\r") );

Console.WriteLine( String.IsNullOrWhiteSpace("\v") );

Console.WriteLine( String.IsNullOrWhiteSpace("\r\n\v ") );

Console.WriteLine( String.IsNullOrWhiteSpace(null) );

Console.WriteLine( String.IsNullOrWhiteSpace("") );

Console.WriteLine( String.IsNullOrWhiteSpace(String.Empty) );

Console.WriteLine( String.IsNullOrWhiteSpace(" ClayrMadeira ") );

Console.ReadLine();

}

No nosso resultado, teremos o seguinte:

True

False

Simples.

Fonte:

http://msdn.microsoft.com/pt-br/library/system.string.isnullorwhitespace.aspx

http://msdn.microsoft.com/pt-br/library/ms228362%28v=vs.90%29.aspx

GridView Paginado com CTE do SQL Server

2011-07-11T19:50:00.000-07:00

Nossas aplicações são cada vez mais complexas, tem cada vez mais informações e cada vez mais deve ser robusta.

Hoje em dia paginação da grade de resultados utilizando o banco de dados esta sendo mais utilizada devido a essa evolução do software. E uma maneira muito simples e poderosa de fazer isso é utilizando da vantagem da CTE do SQL Server.

CTE

Uma CTE (Common Table Expression) tem seu escopo definido pela execução de uma única cláusula (Select, Insert, Update, Delete ou Create View, e pode ser criada a partir do retorno de uma consulta. Como é uma tabela temporária, ela só existe durante a execução da query.

Algumas das vantagens de se utilizar CTE, é que pode ser utilizado o retorno dessa query para fazer união com outras tabelas, e pode utilizar query com hierarquia recursiva.

A sintaxe de uma CTE é demonstrada a seguir:

;WITH expression_name [ ( column_name [,...n] ) ]
AS
( CTE_query_definition )

PROCEDURES

Para fazer a paginação vamos precisar de duas procedures: uma para trazer o total de registros que esta sendo paginado, e outra para trazer os dados da pagina que será mostrada.

A procedure para paginação vai esperar dois parâmetros, sendo ele o tamanho da página e o número da página que vamos buscar o resultado. No exemplo, temos a tabela proposta, onde vamos pegar as informações.

CREATE PROCEDURE dbo.Proposta_Paginada

@PageSize As Int, -- Tamanho da Página

@PageNumber As Int -- Número da Página

-- Evitar que venha 0 na página

IF @PageNumber = 0

SET @PageNumber = 1

-- Minha CTE que é criada a partir de um retorno de uma consulta

; WITH Tabela

(

CodProposta,

Numero,

CPF,

DataAbertura,

DataBaixa,

Observacao,

Resposta,

CodUsuario,

CodUsuarioResposta,

Usuario,

UsuarioResposta,

Posicao

) As (

-- Essa é a consulta que esta preenchendo a CTE

SELECT

Proposta.CodProposta,

Proposta.Numero,

Proposta.CPF,

Proposta.DataAbertura,

Proposta.DataBaixa,

Proposta.Observacao,

Proposta.Resposta,

Proposta.CodUsuario,

Proposta.CodUsuarioResposta,

Usuario.Usuario,

UResposta.Usuario AS UsuarioResposta,

ROW_NUMBER() OVER (ORDER BY CodProposta)

FROM

Proposta

INNER JOIN Usuario ON Usuario.CodUsuario = Proposta.CodUsuario

LEFT JOIN Usuario UResposta ON UResposta.CodUsuario = Proposta.CodUsuarioResposta

)

-- Vamos fazer a condição para pegar só os registros da nossa página

-- que foi passada no parametro

SELECT

CodProposta,

Numero,

CPF,

DataAbertura,

DataBaixa,

Observacao,

Resposta,

CodUsuario,

CodUsuarioResposta,

Usuario,

UsuarioResposta,

Posicao

FROM

Tabela

WHERE

Posicao > (@PageSize * (@PageNumber - 1))

AND

Posicao < (@PageSize * @PageNumber + 1)

A procedure que busca o total é simples:

CREATE PROCEDURE dbo.Proposta_Paginada_Total

DECLARE @COUNTER As Int

-- A consulta só retornará a quantidade de registros

SET @COUNTER = (SELECT COUNT(*) FROM

Proposta

INNER JOIN Usuario ON Usuario.CodUsuario = Proposta.CodUsuario

LEFT JOIN Usuario UResposta ON UResposta.CodUsuario = Proposta.CodUsuarioResposta)

RETURN @COUNTER

ASPX

Vamos adicionar ao projeto uma página para teste.

No nosso exemplo, vamos usar o componente GridView para mostrar as informações, e usar o ObjectDataSource para preencher a nossa grade, onde vamos passar para ele o nome do método público que vai pegar o total de registros que foram paginados (para saber a quantidade de paginas) e passar o método público que busca os registros de uma determinada pagina, logo, na nossa aspx teremos:

<asp:UpdatePanel ID="UpdatePanelGridView" runat="server" UpdateMode="Conditional">

<asp:GridView ID="grvProduto" runat="server" AllowPaging="True" DataSourceID="ObjectDataSource1"

PageSize="4" AutoGenerateColumns="False" DataKeyNames="CodProposta" Width="100%">

<asp:BoundField DataField="CODPROPOSTA" HeaderText="CodProposta" Visible="False" />

<asp:BoundField DataField="NUMERO" HeaderText="Número">

asp:BoundField>

<asp:BoundField DataField="CPF" HeaderText="CPF">

asp:BoundField>

<asp:BoundField DataField="DataAbertura" HeaderText="Abertura" DataFormatString="{0:dd/MM/yyyy}"

HtmlEncode="False">

asp:BoundField>

<asp:BoundField DataField="Usuario" HeaderText="Usuário">

asp:BoundField>

Columns>

asp:GridView>

<asp:ObjectDataSource ID="ObjectDataSource1" runat="server" EnablePaging="True" MaximumRowsParameterName="pageSize"

SelectCountMethod="TotalProdutos" SelectMethod="ConsultaPaginada" StartRowIndexParameterName="pageNumber"

TypeName="NetWeb.Paginas.frmTestePaginacao"> asp:ObjectDataSource>

ContentTemplate>

asp:UpdatePanel>

No lado do Code-behind (CS) temos que criar os métodos públicos que mencionamos no ObjectDataSource. Vamos ao banco de dados somente uma vez pegar a quantidade total de registros e salvar em um ViewState, se precisar recuperar ou limpar é muito simples.

Para isso precisamos de um pequeno método para fazer a conexão com o banco de dados e executar a procedure. Sem entrar em muito detalhe esse será nosso método:

public DataTable carregarTabela(string storedProcedure, SqlParameter[] parametro, ref int? retornoProcedure, Boolean verificaRetornoProcedure)

{

DataTable dtResultado = null;

try

{

//Conexão esta salva no WebConfig

this._conexao.ConnectionString = ConfigurationManager.ConnectionStrings["Conexao"].ConnectionString;

dtResultado = new DataTable("Resultado");

SqlCommand comando = new SqlCommand(storedProcedure, this._conexao);

comando.Parameters.AddRange(parametro);

comando.CommandType = CommandType.StoredProcedure;

this._conexao.Open();

SqlDataAdapter adapter = new SqlDataAdapter(comando);

adapter.Fill(dtResultado);

if(verificaRetornoProcedure)

retornoProcedure = Convert.ToInt32(comando.Parameters["@RETURN_VALUE"].Value);

return dtResultado;

}

catch (Exception ex) { throw ex; }

finally { this._conexao.Close() ; }

}

A página vai conter um atributo tipo SqlConnection para acessar os dados, além dos métodos do ObjectDataSource:

SqlConnection _conexao = new SqlConnection();

public DataTable ConsultaPaginada(int pageSize, int pageNumber)

{

//Busca a Página Atual

Int32 numeroPaginaBusca = (pageNumber == 0 ? 1 : pageNumber) / pageSize;

//Acresta para pegar a proxima página

numeroPaginaBusca++;

//Consulta os Dados

DataTable retorno = this.consulta(pageSize, numeroPaginaBusca);

return retorno;

}

public int TotalProdutos()

{

Int32 ret = 0;

// Busca o Total de Registros para Saber a quantidade de páginas

if (ViewState["total"] == null)

{

ret = this.total();

ViewState["total"] = ret;

}

else

ret = Convert.ToInt32(ViewState["total"]);

return ret;

}

private DataTable consulta(int pageSize, int pageNumber)

{

Int32? ret = 0;

SqlParameter[] parametro = new SqlParameter[2];

//Populando os parametros

parametro[0] = new SqlParameter("@PageSize", pageSize);

parametro[1] = new SqlParameter("@PageNumber", pageNumber);

return this.carregarTabela("Proposta_Paginada", parametro, ref ret, false);

}

private Int32 total()

{

Int32? ret = 0;

SqlParameter[] parametro = new SqlParameter[1];

//Populando os parametros

SqlParameter p = new SqlParameter("@RETURN_VALUE", 0);

p.Direction = ParameterDirection.ReturnValue;

parametro[0] = p;

this.carregarTabela("Proposta_Paginada_Total", parametro, ref ret, true);

return ret.Value ;

}

Colocamos a paginação para ser chamada direto ao carregar a página, porém nada impede de fazer a chamada no clique de um botão de pesquisa.

Utilizando-se da CTE criada e dos nossos objetos de tela, nossa tela ao executar ficará com o resultado:

Saiba mais:

http://msdn.microsoft.com/en-us/library/ms190766.aspx

http://tinyurl.com/6dgv9wu

Arquivos:

http://tinyurl.com/62ktmk6

Trabalhando com Conversão de Datas e Valores Numéricos

2011-06-29T05:41:00.000-07:00

Em todo aplicativo precisamos converter datas, valores e outros dados que depende muito da região. Além do que precisamos nos preocupar com a publicação da aplicação no servidor, que pode esta em outro idioma e afetar o resultado de nossas conversões.

Por exemplo, o usuário pode digitar em uma caixa de texto o valor: 12/07/1985.

DateTime aniversario = Convert.ToDateTime(textBox.Text);

Se o ambiente de publicação estiver configurado em outro idioma, por exemplo, o americano (en-US) o resultado dessa conversão vai ser 07/12/1985.

Podemos adotar uma solução simples, selecionando o idioma direto na Thread ao iniciar a aplicação.

Thread.CurrentThread.CurrentCulture = new CultureInfo("pt-BR");

Thread.CurrentThread.CurrentUICulture = new CultureInfo("pt-BR");

Ou usando a sobrecarga do método Convert:

DateTime data = Convert.ToDateTime("12/07/1985", new CultureInfo("pt-BR"));

Implementando Singleton

2011-06-16T08:00:00.000-07:00

Singleton (também conhecido como Objeto Unitário) é um padrão de projeto criacional que trata da criação de objetos. Muito utilizado e que garante a existência de apenas uma instância da classe em todo projeto, sendo instanciado somente quando precisar, fornecendo um acesso controlado.

Ter uma só instância é uma técnica muito utilizada para classes de criação de Log, impressão e acesso a dados.

Existe diversas formas de implementação do Singleton, algumas mais rápidas, outras com mais segurança.

public sealed class Pessoa

{

private static Pessoa instance = null;

private static readonly object padlock = new object();

Pessoa()

{

}

public static Pessoa Instance

{

get

{

lock (padlock)

{

if (instance == null)

{

instance = new Pessoa();

}

return instance;

}

O código acima tem um bloqueio em um objeto compartilhado, e então verifica ou não a instância foi criada antes da criação da instância. Este cuida da questão da barreira de memória e garante que apenas um thread irá criar uma instância. Infelizmente, por causa do bloqueio cada vez que a instância é solicitada perde-se desempenho.

public sealed class Pessoa

{

private static readonly Pessoa instance = new Pessoa();

private Pessoa() { }

public static Pessoa getInstance

{

get

{

return instance;

}

É simples. Os construtores estáticos em C # são especificados para executar apenas quando uma instância da classe é criado ou um membro estático é referenciado, e para executar apenas uma vez por AppDomain. Aconteça o que acontecer, vai ser mais rápido do que a adição de verificação adicional, como no exemplo anterior.

Se você estiver usando Framework 4 as coisas podem ficar mais simples ainda, tudo que precisa ser feito é passar um delegate para o construtor que chama o construtor Singleton (que ficou mais simples com uma expressão lambda):

public sealed class Pessoa

{

private static readonly Lazy<Pessoa> lazy = new Lazy<Pessoa>(() => new Pessoa());

public static Pessoa Instance { get { return lazy.Value; } }

private Pessoa()

{

}

É simples e funciona bem. Ele também permite que você verifique se a instância foi criado ainda com a propriedade IsValueCreated.

Todos os exemplos acima são consumidos (classe instanciada) da seguinte forma:

Pessoa pessoa = Pessoa.Instance;

Fonte:

http://csharpindepth.com/Articles/General/Singleton.aspx
http://msdn.microsoft.com/pt-br/library/c5kehkcz.aspx
http://msdn.microsoft.com/pt-br/library/ms173150.aspx
http://msdn.microsoft.com/en-us/library/ff650316.aspx

Principalmente:

http://csharpindepth.com/Articles/General/Singleton.aspx

Conversão de Dados usando IValueConverter passando Parâmetro

2011-06-15T14:00:00.000-07:00

Em outra postagem, fizemos um exemplo de implementação da interface IValueConverter para converter valores no binding dos objetos de tela.

http://clayrmadeira.blogspot.com/2011/06/conversao-de-dados-no-binding-usando.html

Vamos usar o mesmo exemplo anterior para exemplificar o uso da interface IValueConverter com passagem de parâmetro.

Na classe que implementa a interface IValueConverter vamos fazer as modificações necessárias para ficar da seguinte forma:

public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

{

DateTime dataHora;

String dataHoraFormatada;

if (DateTime.TryParse(value.ToString(), out dataHora))

{

if(parameter == null)

dataHoraFormatada = dataHora.ToString("dd/MM/yyyy");

else

dataHoraFormatada = dataHora.ToString( parameter.ToString() );

}

else

dataHoraFormatada = String.Empty;

return dataHoraFormatada;

}

public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

{

//Não é Two-Way, logo não precisa implementar o retorno

throw new NotImplementedException();

}

O método esta verificando a existência do parâmetro, caso tenha, vamos usar ele como formatação da data que será mostrada.

Agora a modificação necessária no XAML:

<UserControl x:Class="SilverlightApplication1.MainPage"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

xmlns:meuArquivoConverter ="clr-namespace:SilverlightApplication1"

mc:Ignorable="d"

d:DesignHeight="300" d:DesignWidth="400" >

<UserControl.Resources>

<meuArquivoConverter:ConverterValor x:Key="minhaClasseConvertData" />

UserControl.Resources>

<ComboBox.ItemTemplate>

<TextBlock Text="{Binding Path=DataNasc, Converter={StaticResource minhaClasseConvertData}, ConverterParameter='dd MMM yyy'}" />

StackPanel>

DataTemplate>

ComboBox.ItemTemplate>

ComboBox>

Grid>

UserControl>

Modificamos o XAML colocando o parâmetro ConverterParameter com a formatação que precisamos para mostrar nossa data formata para o usuário. O resultado final é:

Alterando Style no Code Behind - Clonando Styles

2011-06-15T08:00:00.000-07:00

No Silverlight os estilos definem a aparência do objeto entre outras coisas. A diversos casos que precisamos criar objetos dinamicamente e modificar esse estilo para que possa ser usado no objeto recém criado.

Os estilos são write-once em Silverlight, o que significa que você não pode alterar um estilo existente, uma vez que foi atribuido em um objeto.

No entanto, você pode “clonar” um estilo existente, assim você pode remover, modificar ou acrescentar quaisquer propriedades.

Usei essa solução quando foi necessario gerar um gráfico de linha com diversos eixos, clonava a o estilo da linha e modificava somente a cor.

//Criando um Estilo

var meuEstilo = new Style();

meuEstilo.Setters.Add(new Setter(BackgroundProperty, new SolidColorBrush(Colors.Red)));

meuEstilo.Setters.Add(new Setter(ForegroundProperty, new SolidColorBrush(Colors.Blue)));

meuEstilo.Setters.Add(new Setter(BorderThicknessProperty, new Thickness(10)));

//Clonando o estilo

var meuClone = new Style();

foreach (var setter in meuEstilo.Setters)

{

var typedSetter = setter as Setter;

if (typedSetter != null)

{

var newSetter = new Setter(typedSetter.Property, typedSetter.Value);

meuClone.Setters.Add(newSetter);

}

Se estiver utilizando Silverlight 4, pode usar o BaseOn.

var meuEstiloOverride = new Style() { BasedOn = meuEstilo };

meuEstiloOverride.Setters.Add(new Setter(ForegroundProperty, new SolidColorBrush(Colors.Blue)));

meuEstiloOverride.Setters.Add(new Setter(BorderThicknessProperty, new Thickness(10)));

Seu estilo pode esta no XAML, e dentro do code behind ser clonado, assim, basta buscar os dados do XAML, clonar, modificar e atribuir novamente ao objeto de tela.

Style estiloNoXAML = Application.Current.Resources["MeuEstiloNoXAML"] as Style;

Conversão de Dados no Binding usando IValueConverter

2011-06-14T09:18:00.000-07:00

Algo muito comum no desenvolvimento é a formatação de dados para apresentar ao usuário, principalmente quando usamos campos com data, hora e preços.

No Silverlight temos a possibilidade de fazer isso com os conversores (converters) de modo a aplicar uma personalização na hora do binding.

No exemplo, criei uma classe Pessoa só para preencher o objeto de tela:

namespace SilverlightApplication1

{

public class Pessoa

{

public DateTime DataNasc { get; set; }

public String Nome { get; set; }

}

Inicialmente no arquivo XAML, será colocado uma combobox para exemplificar como ficará o carregamento normal das informações.

<ComboBox.ItemTemplate>

StackPanel>

DataTemplate>

ComboBox.ItemTemplate>

ComboBox>

Grid>

No código da página, vamos preencher nosso objeto de tela da seguinte forma:

public MainPage()

{

InitializeComponent();

this.inicializar();

}

private void inicializar()

{

this.comboBox1.ItemsSource = colecaoPessoa();

}

private List<Pessoa> colecaoPessoa()

{

List<Pessoa> colecao = new List<Pessoa>();

colecao.Add(new Pessoa() { DataNasc = new DateTime(1985, 07, 18), Nome = "Clayr Madeira" });

colecao.Add(new Pessoa() { DataNasc = new DateTime(1989, 08, 26), Nome = "Raianne Motoshima" });

colecao.Add(new Pessoa() { DataNasc = new DateTime(1965, 09, 07), Nome = "Nilo Gonçalves" });

colecao.Add(new Pessoa() { DataNasc = new DateTime(1992, 01, 12), Nome = "José Couve" });

return colecao;

}

Ao executar, teremos o resultado da seguinte forma:

A formatação não ficou adequada para o padrão brasileiro, além de conter informações demais para mostrar somente a data de nascimento. Vamos fazer essa formatação usando os conversores, para nosso exemplo, criei uma classe com o nome ConverterValor que herda da interface IValueConverter.

namespace SilverlightApplication1

{

public class ConverterValor : IValueConverter

{

#region IValueConverter Members

public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

{

DateTime dataHora;

if (DateTime.TryParse(value.ToString(), out dataHora))

return dataHora.ToString("dd/MM/yyyy");

else

return 0;

}

public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

{

//Não é Two-Way, logo não precisa implementar o retorno

throw new NotImplementedException();

}

#endregion

}

A interface IValueConverter tem dois métodos que devem ser implementados - Convert e ConvertBack. O método Convert é usado para converter o valor passado. O método ConvertBack é usado quando o binding é two-way, assim convertendo o valor de entrada de volta para o código fonte.

Após a criação da classe é preciso dar o Build Solution e referenciar a namespace no XAML, para isso deve-se criar um novo include na chave do UserControl e referenciar também no UserControl.Resources colocando um nome para poder fazer a chamada da classe:

<UserControl x:Class="SilverlightApplication1.MainPage"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

xmlns:meuArquivoConverter ="clr-namespace:SilverlightApplication1"

mc:Ignorable="d"

d:DesignHeight="300" d:DesignWidth="400" >

<UserControl.Resources>

<meuArquivoConverter:ConverterValor x:Key="minhaClasseConvertData" />

UserControl.Resources>

Após essa referencia no arquivo adicionando o namespace/classe que vamos usar para converter a data, a modificação será no binding do template do combobox

StackPanel>

DataTemplate>

Ao executar o programa teremos a data de nascimento formatada.

Tuples - Tuplas no C# 4

2011-06-10T08:00:00.000-07:00

O conceito de tupla é bem antigo no mundo do desenvolvimento de sistemas, principalmente no banco de dados:

Cada linha formada por uma lista ordenada de colunas representa um registro, ou tupla. Os registros não precisam conter informações em todas as colunas, podendo assumir valores nulos quando assim se fizer necessário. Resumidamente, um registro é uma instância de uma tabela, ou entidade.

Só que as tuplas foram inseridas no C# 4 como programação dinâmica. As tuplas fornecem vários valores em um único resultado de uma maneira rápida, sem a necessidade de criar parâmetros de referencia do tipo out.

As tuplas tem o limite de oito itens, sendo que o oitavo item necessariamente deve ser uma tupla. No C# a classe Tuple é estática, logo pode chamar o método Create para criar sua tupla, ou só instanciar.

Tuple<int, string, DateTime> minhaPrimeiraTupla =

Tuple.Create(1, "Clayr", new DateTime(1985, 7, 18));

var minhaTupla = new Tuple<int, string>(1, "Clayr");

Ao criar sua nova tupla, vão aparecer os itens de uma forma tipada, no nosso exemplo o Item1 será inteiro, Item2 string e Item3 um tipo de data e hora:

Além disso, usando tuplas não precisamos criar classes ou estruturas só para armazenar valores temporários. Um exemplo clássico é quando criamos classes para preencher objetos de tela, como combobox, listbox e outros.

Desempenho

Alguns testes de desempenho foram executados no Tuple eo KeyValuePair struct. Esta comparação de desempenho só é relevante nos casos em que uma tupla de dois elementos é usada, como o KeyValuePair sempre tem dois itens. Nos testes de desempenho, o KeyValuePair foi mais rápida quando muitas situações foram criadas, mas a tupla foi mais rápida quando a ocorrência foi passada para muitos métodos como um argumento. Isso deriva do fato de que a tupla é uma classe e os KeyValuePair é uma estrutura.

Fonte:

http://www.dotnetperls.com/tuple

http://msdn.microsoft.com/en-us/library/system.tuple.aspx

http://pt.wikipedia.org/wiki/Banco_de_dados_relacional#Registros_.28ou_tuplas.29

Compatibilidade dos Navegadores com Silverlight 4

2011-06-09T18:25:00.000-07:00

Desenvolver em Silverlight 4 para Web é bem diferente e desafiador. Passei pelo desafio de compatibilidade dos navegadores, como já sabia que Silverlight 4 não é executado em alguns navegadores, tive que prevenir para o usuário não ficar com a página em branco. Veja a lista:

Então é detectar o browser do usuário e Sistemas operacional para habilitar ou não o Silverlight ou até mesmo redirecionar para outra página com a funcionalidade em HTML.

//Windows 7 com IE7 ou iOS(Iphone, Ipod e Ipad) não será apresentado o link do Silverlight

System.Web.HttpBrowserCapabilities browser = Request.Browser;

if( ( browser.Browser == "Safari" && browser.Platform.StartsWith( "Win" ) ) ||
( browser.Browser == "IE" && browser.Version == "7.0" && browser.Platform == "Win7" ) ||( browser.Browser.StartsWith( "iOS" ) ) || ( HttpContext.Current.Request.UserAgent.ToLower().Contains( "ipad" ) ) )
{
this.meuLinqSilverlight.Visible = false;
}

Microsoft Mathematics 4.0

2011-04-18T17:49:00.000-07:00

Microsoft Mathematics que agora não é mais pago, chegou na sua versão 4.0 com ótimas funções para alunos e profissionais que precisam resolver cálculos complexos, com gráficos e passo a passo. Com gráficos em 2D e 3D o software permite resolver equações , conversão de unidades e resolução de problemas com triângulos.

Os gráficos podem girar e o software permite entrada de dados de uma forma manual.
Da uma olhada nessa ferramenta, que vai lhe ajudar nos cálculos da faculdade.

Download
Download 64 bits
Download 32 bits