Paulo Morgado

Revista PROGRAMAR – 33ª Edição Fevereiro de 2012

Paulo Morgado — Fri, 03 Feb 2012 01:49:52 Z

Revista PROGRAMAR

Edição 33 – Fevereiro de 2012

Nesta edição, a revista Programar continua a premiar os autores dos três melhores artigos, dado o sucesso nas edições anteriores. E os leitores devem dar a sua opinião para que possamos premiar correctamente. Para isso vote em http://tiny.cc/ProgramarED33_V

Assim nesta edição o artigo de capa é um artigo sobre Kinect Hack para conhecer melhor algumas técnicas de programação para este novo dispositivo. Nesta 33ª edição podem ainda encontrar-se os seguintes artigos:

Geração de Números Aleatórios – Parte 3 - O terceiro de 4 artigos do mesmo autor da excelente série “Programação em Lua”, desta vez sobre geração de números aleatórios.
Herança com JavaScript - Saiba como usar a funcionalidade herança do paradigma da programação orientada por objetos na linguagem de programação JavaScript.
Programação Orientada aos Objectos em Pascal - Pensa que o Pascal é uma linguagem apenas de aprendizagem e que parou no tempo? Então mude de ideias e veja como pode tirar partido do paradigma da programação orientada aos objetos nesta linguagem.
VISUAL (NOT) BASIC -Iterators - Saiba como pode utilizar iteradores na próxima versão da linguagem de programação Visual Basic (neste momento disponível em Developer Preview).
CORE DUMP – Ambientes Produtivos - Será que os ambientes produtivos disponibilizados pela gestão aos trabalhadores são os melhores? Conheça a opinião deste autor.
Enigmas de C#: Disposable Structs - Mais um dos meus artigos sobre enigmas da linguagem de programação C#, desta vez envolvendo Disposable Structs.

E ainda em colaboração com as comunidades NetPonto, AzurePT e SharepointPT, respectivamente:

BizTalk Server – Como funcionam os mapas - Continuação do artigo sobre princípios básicos dos mapas publicado na edição anterior.
SQL Azure Federations na prática - Aprenda a implementar o padrão Sharding, que permite aumentar a escalabilidade de bases de dados de grandes dimensões.
Desenvolvimento em SharePoint 2010 – Parte 2 - Continuação do artigo anterior, desta vez saiba como desenvolver um sistema básico de logging.

Mais informação

App Me Up | Windows Phone

Paulo Morgado — Tue, 24 Jan 2012 22:56:12 Z

Já está disponível o sítio da última iniciativa da Microsoft Portugal para o lançamento do Windows Phone: App Me Up | Windows Phone

Com esta iniciativa, a Microsoft Portugal pretende contribuir para que Portugal se torne um dos países de referência no desenvolvimento de aplicações para Windows Phone.

Revista PROGRAMAR – 32ª Edição Dezembro 2011

Paulo Morgado — Fri, 09 Dec 2011 23:54:00 Z

(clica para download)

Com o Natal por perto, a equipa de Revista PROGRAMAR traz-nos um presente de Natal, a edição de Dezembro recheada de óptimos artigos.

Nesta edição continuaremos também a premiar os autores dos três melhores artigos, dado o sucesso nas edições anteriores. E os leitores devem dar a sua opinião para que possamos premiar correctamente. Para isso vote em http://tiny.cc/ProgramarED32_V

Esta edição traz-nos, como artigo de capa, um artigo sobre iOS, Cocoa Touch & MVC para conhecer melhor algumas técnicas de programação para dispositivos móveis da Apple.

Nesta 32ª edição podemos ainda encontrar os seguintes artigos:

Geração de Números Aleatórios – Parte 2
O segundo de 4 artigos do mesmo autor da excelente série «Programação em Lua», desta vez sobre geração de números aleatórios.
Automatização de tarefas usando atributos
Continuação do artigo sobre atributos em C# da edição número 30. Neste artigo, conheça melhor o funcionamento do conceito de contextos nesta linguagem.
SQL Azure Fedarations
Introdução às SQL Azure Federations.
Enigmas de C#: Arrays
Saiba porque motivo, um array pode provocar uma System.ArrayTypeMismatchException.
Espero que este pequeno artigo de minha autoria seja o primeiro de muitos acerca das peculiaridades do C# que se apresentam como verdadeiros enigmas no nosso dia a dia.
VISUAL (NOT) BASIC – Um pouco mais de Windows Phone 7
Como pode tirar partido de algumas funcionalidades e características no desenvolvimento de aplicações para esta plataforma.
CORE DUMP – Free as in Beer
Atualmente, as empresas usam software open source, não por ser livre, mas por ser grátis. Conheça a opinião do autor sobre este tema.

E ainda em colaboração com as comunidades AzurePt e NetPonto, respectivamente:

Como suportar múltiplas identidades no seu WebSite com Windows Azure AppFabric ACS
Saiba como resolver o problema das identidades em demasia através do Azure.
BizTalk Server – Princípios Básicos dos Mapas
Explore através deste artigo, o editor de mapas do BizTalk Server.

Desejos de Boas Festas à equipa da Revista PROGRAMAR e a todos os leitores, redactores e membros da comunidades com as quais está relacionada.

Becoming a Kinect (Hacker) Innovator

Paulo Morgado — Thu, 03 Nov 2011 00:30:20 Z

O Jeff Sipko, da equipa Kinect Hack and Share da Microsoft, que estará presente no SAPO Codebits deste ano para falar do novo Kinect SDK, conseguiu à última hora garantir a disponibilidade para estar em Portugal uns dias antes, e apresentar em exclusivo para a comunidade de Developers Microsoft uma sessão sobre o que podemos fazer com o Kinect SDK.

Quem não quiser perder esta oportunidade pode inscrever-se aqui.

Mas, então, o que precisamos saber sobre esta sessão?

Kinect motion sensor broke a Guiness record by being the fastest selling consumer electronics device ever ! Shortly after the device was launched, the community began creating solutions to enable them to connect the device to their computers and consume the sensor data for their own purposes. We have seen some astounding innovation come from this—enhancing everything from games to robotics to surgery—and this is only the beginning!
This talk will give you some of the highlights of what people have been building with the system, and how they made it happen, then will show you how easy it is to use the tools to start creating your own amazing products with the system! You are the visionary! You are the controller!

O SDK e vários outros recursos podem ser obtidos no site http://research.microsoft.com/kinectsdk.

Anunciando A CTP Do Microsoft Roslyn

Paulo Morgado — Wed, 19 Oct 2011 23:56:13 Z

A equipa do Roslyn anunciou a disponibilidade geral do Roslyn CTP!

O lançamento oficial pode ser encontrado em http://msdn.com/roslyn, assim como em algumas entradas de blogues (soma, ericli, vsteam, vbteam, c#faq) e pelo Twitter.

Este lançamento marca um passo significante no modo de pensar acerca dos compiladores, a agilidade tornada agora possível com inovação nas linguagens, ferramentas de IDE e potenciação do ecossistema. Os compiladores de C# e VB deixam de ser caixas pretas – algo para onde despejamos texto, opera alguma magia e despeja uma assembly cá para fora. Toda a riqueza de informação acerca do código já não é deitada fora mas exposta como um modelo de objectos de total fidelidade que pode facilmente ser consumido por todos. Adicionalmente, foi lançada uma como antevisão da primeira janel interactiva de C# que dispõe de todo o suporte do IDE – incluindo IntelliSense e detecção automática de directivas using em falta.

Como começar:

Descarregar a CTP. A CTP é instalada sobre o Visual Studio 2010 SP1 e pode ser instalada com segurança lado-a-lado com o Visual Studio 11.
Ir a Start -> All Programs -> Microsoft Codename Roslyn CTP -> Getting Started para lançar o ponto de entrada para toda a documentação, exemplos e ferramentas.
Leiam o Roslyn Project Overview para uma melhor visão do projecto.
Aprendam com os ricos exemplos incluído (colar como C#/VB, refactorings, análise de código e ferramentas de geração de código).
Corram os walkthroughs para aprender as APIs do compilador, s APIs dos serviços usar a janela interactiva.
Qve extensões, pode descarregar a CTP ara experimentar a janela interactiva e usar as extensões Copiar Colar C#/VB que foram criadas para nos ajudar no trabalho diário!

Esta distribuição inclui as seguintes funcionaliades:

Visual Studio Project Templates
Estes modelos de projecto ajudam nos primeiro passos da utilizaão das APIs do Roslyn e a construir novas extensões para o Visual Studio usando as APIs do C# ou VB.
Reference Assemblies
As assemblies do Roslyn podem ser adicionadas aos projecto através da janela Add Reference.
Interactive Window
A nova janela chamada C# Interactive está disponível no Visual Studio invocando View -> Other Windows -> C# Interactive a partir do menu. A partir daí podem-se experimentar quer executando pequenos pedaços de código quer construindo cumulativamente um contexto de execução à medida que se vai experimentando.
Script File Editing Support
Os ficheiros C# Script (.csx) permitem instruções de alto nível como a janela C# Interactive. Pode-se criar um novo ficheiro de C# Script invocando File -> New File -> Script -> Visual C# Script a partir do menu do Visual Studio. Adicionalmente a digitar o código directamente na janela, é possível seleccionar código em C# e ficheiros C# Script (.csx) e invocar "Execute in Interactive" ou "Copy to Interactive" a partir do menu de contexto. As funcionalidades de edição do C# Script, como o IntelliSense, são disponibilizadas usando o Roslyn Language Service.

Tenham em atenção de que isto é apenas uma antevisão da tecnologia (technology preview) e não produto final! O principal objectivo desta CTP é recolher testemunhos acerca das APIs públicas e permitir uma visão antecipada da janela Interactive. O formato das APIs está num estado razoavelmente estável, principalmente o as do compilador, mas ainda existem ainda algumas limitações conhecidas e apenas um conjunto das linguagens C# e Visual Basic estão implementadas na actual distribuição. Para a lista completa das funcionalidades não implementadas das linguagens, ver aqui. A janela Interactive está disponível apenas em C# neste momento, mas o VB seguir-se-á em breve.

A equipa do Roslyn aguarda testemunhos nos foruns e Connect.

O Que É A .NET Framework 4.5?

Paulo Morgado — Sun, 16 Oct 2011 23:56:00 Z

De acordo com o .NET Blog, a .NET Framework 4.5 é uma actualização da .NET Framework 4.0 que a substitui (ao contrário de uma instalação lado-a-lado). TO objectivo é a .NET 4.5 ser totalmente compatível (backward compatible) com aplicações feitas para .NET 4.0 (.NET 3.5 e .NET 4.5 estarão instaladas lado-a-lado).

Uma das primeiras cosias que se nota acerca da .NET 4.5 é que o número de versão da CLR (4.0.30319) é o mesmo da .NET 4.0; esta é a práctica comum usada por outras actualizações. (ler mais)

The facto, se se comparar um sistema com .NET 4.5 com um sistema com .NET 4.0 confirma-se que a 4.5 é apenas uma actualização à 4.0:

Registry key: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full
Value	.NET 4.0	.NET 4.5
Version	4.0.30319	4.5.40805
CBS	1	1
TargetVersion	4.0.0	4.0.0
Install	1	1
Servicing	0	0
Release		368485
InstallPath	C:\Windows\Microsoft.NET\Framework64\v4.0.30319\	C:\Windows\Microsoft.NET\Framework64\v4.0.30319\

Uma das principais adições à plataforma é o suporte para a Task-based Asynchronous Pattern. Todas as classes com APIs assíncronas foram aumentadas para com uma API assíncrona Task-based.

O tratamento de excepções de tasks também muda na .NET 4.5 para acomodar a nova palavra chave async do C# e VB. (ler mais)

User Agent Strings Do Internet Explorer 10 No Windows 8 de 64bit

Paulo Morgado — Mon, 10 Oct 2011 23:15:43 Z

O Internet Explorer 10 é o navegador web fornecido pela Microsoft com o Windows 8.

De acordo com as suas diferentes utilizações, a sua user agent string é a seguinte:

Application	Environment	32/64 bit	User Agent String
Internet Explorer	Metro	-	Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Win64; x64; Trident/6.0)
Aplicação Javascript	Metro	-	Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0;)
Aplicação C#/VB	Metro	32bit	Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)
Aplicação C#/VB	Metro	64bit	Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Win64; x64; Trident/6.0)
Internet Explorer	Desktop	32bit	Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)
Internet Explorer	Desktop	64bit⁽¹⁾	Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Win64; x64; Trident/6.0)
Aplicação WPF	Desktop	32bit	Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.2; WOW64; Trident/6.0; .NET4.0E; .NET4.0C; Tablet PC 2.0; .NET CLR 3.5.30729; .NET CLR 3.0.30729; .NET CLR 2.0.50727; Zune 4.7; InfoPath.3)
Aplicação WPF	Desktop	64bit	Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.2; Win64; x64; Trident/6.0; .NET4.0E; .NET4.0C; Tablet PC 2.0; .NET CLR 3.5.30729; .NET CLR 3.0.30729; .NET CLR 2.0.50727; Zune 4.7; InfoPath.3)

⁽¹⁾ Necessita ser habilitado para cada zona de segurança.

Analizando a tabela acima, concluo que:

Internet Explorer Metro é sempre uma aplicação de 64bit no Windows 8 64bit.
Aplicações Metro Javascript não anunciam se são de 32bit ou 64bit.
1. Aparentam estar a correr num Windows 8 de 32bit.
Internet Explorer Desktop mantém o comportamento introduzido com o Internet Explorer 8.
Aplicações C#/VB Metro hospedando o web browser (WebView control) exibem o mesmo comportamento que o Internet Explorer.
Aplicações Desktop WPF hospedando o web browser (WebBrowser control) mantém o comportamento introduzido com o Internet Explorer 8.
1. Este comportamento pode ser sobreposto definindo o modo de compatibilidade do documento no servidor ou definindo o modo de emulação do navegador no cliente.

Keynotes da BUILD | Online e em directo

Paulo Morgado — Tue, 13 Sep 2011 00:50:43 Z

A BUILD, a conferência onde se espera que a Microsoft apresente as primeiras novidades sobre o Windows 8, para Developers, está prestes a iniciar. A boa notícia é que as Keynotes estarão disponíveis online e em directo no site www.buildwindows.com!

O Channel9 também vai ter uma cobertura muito extensa da conferência, entre sessões disponíveis online, entrevistas, painéis de discussão, etc. (mais novidades aqui: http://news.cnet.com/8301-10805_3-20103036-75/behind-the-scenes-at-microsofts-channel-9/)

Limpado HTML Com Expressões Regulares

Paulo Morgado — Mon, 05 Sep 2011 03:57:07 Z

Ao participar numa discussão de um fórum, ocorreu a necessidade de limpar HTML de fragmentos "perigosos".

No caso presente, era necessário remover os elementos SCRIPT, OBJECT, APPLET, EMBBED, FRAMESET, IFRAME, FORM, INPUT, BUTTON e TEXTAREA (tanto quanto me consiga ocorrer) do HTML fonte. Todos os atributos relativos a eventos (ONEVENT) deveriam ser removidos mantendo, no entanto, os restantes.

O HTML é muito pouco rigoroso e difícil de interpretar. Os elementos podem ser definidos por uma etiqueta (tag) inicial (<nome-do-elemento>) e uma etiqueta final (</nome-do-elemento>) existindo, no entanto, alguns elementos que não requerem etiqueta final. Se estiver a ser interpretado XHTML, elementos sem a etiqueta final requerem que a etiqueta seja terminada com /> em vez de apenas >.

Os atributos não são mais fáceis de interpretar. Por definição, os valores dos atributos requerem que sejam delimitados por plicas (') ou aspas ("), mas alguns navegadores aceitam valores sem qualquer delimitador.

Poderíamos construir um interpretador (parser), mas isso tornaria demasiado custoso adicionar ou remover elementos ou atributos. Usar uma expressão regular para remover os elementos e atributos indesejados para ser a melhor opção.

Comecemos por capturar os elementos definidos com etiqueta inicial e etiqueta final. Para tal, temos de:

Capturar o carácter de início de etiqueta seguido do inicial seguido do nome do elemento (que memorizaremos – t): <(?<t>nome-do-elemento)
Capturar opcionalmente espaços iniciais seguidos de qualquer carácter: (\s+.*?)?
Capturar o carácter de fim de etiqueta: >
Capturar opcionalmente qualquer carácter: .*?
Capturar o carácter de início de etiqueta seguido do carácter de etiqueta final, o nome do elemento (referenciado pelo nome com que foi memorizado - t) e o carácter de fim de etiqueta: </\k<t>>

<?<t>nome-do-elemento(\s+.*?)?>.*?</\k<t>>

Para capturar todos os elementos indesejados, chegamos à seguinte expressão regular:

<(?<t>script|object|applet|embbed|frameset|iframe|form|textarea)(\s+.*?)?>.*?</\k<t>>

Em seguida, capturemos os elementos sem etiqueta final. Para tal, temos de:

Capturar o carácter de início de etiqueta seguido do inicial seguido do nome do elemento: <nome-do-elemento
Capturar opcionalmente espaços iniciais seguidos de qualquer carácter: (\s+.*?)?
Capturar o carácter de etiqueta final opcional: /?
Capturar o carácter de fim de etiqueta: >

<nome-do-elemento(\s+.*?)?/?>

Para capturar todos os elementos indesejados, chegamos à seguinte expressão regular:

<(script|object|applet|embbed|frameset|iframe|form|textarea|input|button)(\s+.*?)?/?>

Para remover todos estes elementos indesejáveis do HTML fonte, podemos combinar as duas expressões regulares anteriores numa só e substituir todas as capturas por texto vazio:

Regex.Replace(
    sourceHtml,
    "|(<(?<t>script|object|applet|embbed|frameset|iframe|form|textarea)(\\s+.*?)?>.*?</\\k<t>>)"
        + "|(<(script|object|applet|embbed|frameset|iframe|form|input|button|textarea)(\\s+.*?)?/?>)",
    string.Empty);

Finalmente, os atributos indesejáveis. Esta operação é um pouco mais complicada porque queremos capturar os atributos indesejáveis dentro da definição de elementos. Para o conseguir, temos de procurar uma combinação que corresponda à etiqueta inicial de um elemento e capturar a definição dos atributos. Para tal, temos de:

Encontrar mas ignorar o carácter de início de etiqueta seguido de qualquer nome do elemento: (?<=<\w+)
Encontrar todos:
- Não capturar espaços: (?:\s+)
- Capturar definição de atributo:
  - Capturar nome de atributo: \w+
  - Capturar sinal de igualdade: =
  - Capturar o valor numa das formas:
    - Capturar valor delimitado por aspas: "[^"]*"
    - Capturar valor delimitado por plicas: '[^']*'
    - Capturar valor não delimitado: .*?
Encontrar mas ignorar fim de etiqueta: (?=/?>)

(?<=<\w+)((?:\s+)(\w+=(("[^"]*")|('[^']*')|(.*?)))*(?=/?>)

O problema da expressão regular anterior é que corresponde e captura todos os atributos em conjunto e não cada atributo indesejado individualmente. Isto impede-nos de substituir a captura por um texto fixo (texto vazio).

Para solucionar isto, temos de dar um nome aos atributos que queremos capturar e usar o método Replace que usa um avaliador de correspondências - MatchEvaluator.

Poderíamos capturar os elementos indesejados com fizemos para os elementos, mas teríamos de os remover da lista de todos os atributos do elemento. Em vez disso, iremos capturar os atributos desejados e construir a lista de atributos. Para identificar quais os atributos desejados teremos de lhes dar um nome (a). O código resultante será algo deste género:

Regex.Replace(
    sourceHtml,
    "((?<=<\\w+)((?:\\s+)((?:on\\w+=((\"[^\"]*\")|('[^']*')|(.*?)))|(?<a>(?!on)\\w+=((\"[^\"]*\")|('[^']*')|(.*?)))))*(?=/?>))",
    match =>
    {
        if (!match.Groups["a"].Success)
        {
            return string.Empty;
        }
        
        var attributesBuilder = new StringBuilder();
        
        foreach(Capture capture in match.Groups["a"].Captures)
        {
            attributesBuilder.Append(' ');
            attributesBuilder.Append(capture.Value);
        }
        
        return attributesBuilder.ToString();
    }
);

Para evitar interpretar o HTML fonte mais de uma vez, podemos combinar todos as expressões regulares numa só.

Porque apenas iremos retornar os atributo desejados, não há qualquer alteração a fazer ao avaliador de correspondências.

Acrescentemos ainda algumas opções (RegexOptions) para acrescentar funcionalidade e performance:

IgnoreCase: Para corresponder maiúsculas e minúsculas.
CultureInvariant: Para ignorar diferenças culturais de linguagem.
Multiline: Para modo multi-linha.
ExplicitCapture: Para capturar apenas capturas com nome.
Compiled: Para compilar a expressão regular para uma assembly. Apenas se a expressão regular for usada muitas vezes.

The resulting code will be this:

Regex.Replace(
    sourceHtml,
    "(<(?<t>script|object|applet|embbed|frameset|iframe|form|textarea)(\\s+.*?)?>.*?</\\k<t>>)"
        + "|(<(script|object|applet|embbed|frameset|iframe|form|input|button|textarea)(\\s+.*?)?/?>)"
        + "|((?<=<\\w+)((?:\\s+)((?:on\\w+=((\"[^\"]*\")|('[^']*')|(.*?)))|(?<a>(?!on)\\w+=((\"[^\"]*\")|('[^']*')|(.*?)))))*(?=/?>))",
    match =>
    {
        if (!match.Groups["a"].Success)
        {
            return string.Empty;
        }
        
        var attributesBuilder = new StringBuilder();
        
        foreach(Capture capture in match.Groups["a"].Captures)
        {
            attributesBuilder.Append(' ');
            attributesBuilder.Append(capture.Value);
        }
        
        return attributesBuilder.ToString();
    },
    RegexOptions.IgnoreCase
        | RegexOptions.CultureInvariant
        | RegexOptions.Multiline
        | RegexOptions.ExplicitCapture
        | RegexOptions.Compiled
);

Isto não foi extensivamente testado e pode ocorrer que algum HTML desejado seja removido e algum HTML indesejado sejam mantido, mas deve estar próximo de uma boa solução.

Conteúdos do Microsoft Summer Tech Refresh

Paulo Morgado — Fri, 12 Aug 2011 13:59:46 Z

No passado dia 10 de Agosto teve lugar no auditório da Microsoft Portugal o Microsoft Summer Tech Refresh.

O evento abriu com um agradável convívio no exterior com comes e bebes a que se seguiu uma série de apresentações sobre a construção de uma aplicação usando diferentes tecnologias e serviços Microsoft. Um evento a repetir.

Todos os conteúdos do evento estão disponíveis nesta pasta de SkyDrive.

O Novo MSDN Forums Assistant

Paulo Morgado — Mon, 18 Jul 2011 00:21:41 Z

A Microsoft lançou o MSDN Forum Assistant, que permite acesso aos foruns MSDN e receber actualizações directamente no seu ambiente de trabalho. A funcionalidades incluem Ask a Question, Latest Post, Thread Updates, Priority Support, e Forum Q&A. O MSDN Forum Assistant pode ser descarregado daqui: http://gallery.live.com/liveItemDetail.aspx?li=822a3787-89e8-4c6d-8fc4-a413437d86e9

Mais informação pode ser encontrada aqui:

MSDN Forum Assistant Web Site: http://msdn.microsoft.com/en-sg/gg650455
Video Overview: http://www.youtube.com/watch?v=JYrNemrjQc8

Visual Studio UserVoice Site

Paulo Morgado — Sun, 17 Jul 2011 23:42:00 Z

Foi criado um sítio UserVoice para recolher pedidos e opiniões da comunidade acerca do Visual Studio:

http://visualstudio.uservoice.com/

Para reportar problemas, o sítio Visual Studio Connect continua a ser o local indicado:

http://connect.microsoft.com/visualstudio

GUID Generator: My first Windows Phone application is available on the marketplace

Paulo Morgado — Sun, 17 Jul 2011 22:28:25 Z

Para poder completar o registo para poder desenvolver para o Windows Phone é necessário submeter uma aplicação.

Seguindo o conselho do Caio, criei um gerador de GUIDs - GUID Generator. Já foi publicado e pode ser obtido aqui.

Alguma vez sentiram a necessidade de um GUID fresquinho?

Com esta aplicação pode ter o seu GUID gerado de fresco quando quiser.

Um GUID (Globally Unique Identifier) é um número inteiro de 128 bits (16 bytes) que pode ser usado em de todos os computadores e redes sempre que um identificador único for requerido. Tal identificador tem uma probabilidade muito reduzida de ser duplicado. Alguém quer tentar?

Falando com amigos com telefones iPhone e Android apercebi-me de que não existe tal aplicação para essas plataformas. Como é que conseguem sobreviver sem uma?

Métodos De Extensão E Inferência De Tipos Em Acção

Paulo Morgado — Mon, 18 Apr 2011 00:43:06 Z

Eu uso extensivamente métodos de extensão, quer seja para manter as clases pequenas e focadas, quer seja para melhorar a legibilidade do código.

Enquanto portava uma aplicação WinForms da platafirnma .NET 1.1 para C# 3.0, encontrei código como este:

delegate int Int32DelegateStringBoolean(string text, bool flag);

void DoStuff()
{
    // ...

    var x = (int)this.Invoke(new Int32DelegateStringBoolean(GetStuff), new object[] { "some text", true });

    // ...
}

int GetStuff(string text, bool flag)
{
    // ...
}

A .NET 2.0 introduziu uma API e tornou possível escrever o código de chamada a Invoke assim:

var x = (int)this.Invoke(new Int32DelegateStringBoolean(GetStuff), "some text", true);

Mas isto ainda não está fortemente tipado como eu gosto e o compilador não consegue verificar se me enganei. Este código será válido em tempo de compilação mas rebentará em tempo de execução:

var x = (long)this.Invoke(new Int32DelegateStringBoolean(GetStuff), "some text", 10M, 5);

Para tornar o código mais seguro e legível, decidi criar métodos de extensão para estender a classe Control e providenciar métodos Invoke fortemente tipados.

Em vez de definir delegates à medida para cada necessidade, usei os delegates Action e Func existentes na plataforma e criei métodos de extensão como este:

public static TResult InvokeFunc<T1, T2, TResult>(this Control control, Func<T1, T2, TResult> func, T1 param1, T2 param2)
{
    return (TResult)(control.Invoke(func, param1, param2));
}

Agora é possível substituir a chamada a Invoke por esta chamada:

var x = this.InvokeFunc<string, bool, int>(new Func<string, bool, int>(GetStuff), "some text", true);

E agora o compilador consegue validar o tipo o delegate, dos parâmetros e do valor de retorno.

Desde a introdução do C# 2.0 que não é necessário escrever o código de instanciação do delegate se o compilador conseguir inferir o seu tipo, o que torna o código ainda mais simples:

var x = this.InvokeFunc<string, bool, int>(GetStuff, "some text", true);

O compilador de C# é ainda capaz de inferir o tipo dos parâmetors de InvokeFunc tornado o código ainda mais simples e legível:

var x = this.InvokeFunc(GetStuff, "some text", true);

Muito melhor do que aquilo com que começamos, não é?

Até ao momento já implementei os seguintes:

/// <summary>
/// Provides extended functionality to <see cref="System.Windows.Forms.Control"/>.
/// </summary>
public static class ControlExtensions
{
    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to invoke the function on.</param>
    /// <param name="func">The function to invoke.</param>
    /// <returns>A <typeparamref name="TResult"/> that contains the return value from the function (<paramref name="func"/>) being invoked.</returns>
    public static TResult InvokeFunc<TResult>(this Control control, Func<TResult> func)
    {
        return (TResult)(control.Invoke(func));
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to invoke the function on.</param>
    /// <param name="func">The function to invoke.</param>
    /// <param name="param1">The parameter of the action.</param>
    /// <returns>A <typeparamref name="TResult"/> that contains the return value from the function (<paramref name="func"/>) being invoked.</returns>
    public static TResult InvokeFunc<T1, TResult>(this Control control, Func<T1, TResult> func, T1 param1)
    {
        return (TResult)(control.Invoke(func, param1));
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to invoke the function on.</param>
    /// <param name="func">The function to invoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <returns>A <typeparamref name="TResult"/> that contains the return value from the function (<paramref name="func"/>) being invoked.</returns>
    public static TResult InvokeFunc<T1, T2, TResult>(this Control control, Func<T1, T2, TResult> func, T1 param1, T2 param2)
    {
        return (TResult)(control.Invoke(func, param1, param2));
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to invoke the function on.</param>
    /// <param name="func">The function to invoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <param name="param3">The third parameter of the function.</param>
    /// <returns>A <typeparamref name="TResult"/> that contains the return value from the function (<paramref name="func"/>) being invoked.</returns>
    public static TResult InvokeFunc<T1, T2, T3, TResult>(this Control control, Func<T1, T2, T3, TResult> func, T1 param1, T2 param2, T3 param3)
    {
        return (TResult)(control.Invoke(func, param1, param2, param3));
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the function.</typeparam>
    /// <typeparam name="T4">The type of the forth parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to invoke the function on.</param>
    /// <param name="func">The function to invoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <param name="param3">The third parameter of the function.</param>
    /// <param name="param4">The forth parameter of the function.</param>
    /// <returns>A <typeparamref name="TResult"/> that contains the return value from the function (<paramref name="func"/>) being invoked.</returns>
    public static TResult InvokeFunc<T1, T2, T3, T4, TResult>(this Control control, Func<T1, T2, T3, T4, TResult> func, T1 param1, T2 param2, T3 param3, T4 param4)
    {
        return (TResult)(control.Invoke(func, param1, param2, param3, param4));
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <param name="control">The control to invoke the action on.</param>
    /// <param name="action">The action to invoke.</param>
    public static void InvokeAction(this Control control, Action action)
    {
        control.Invoke(action);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T">The type of the parameter.</typeparam>
    /// <param name="control">The control to invoke the action on.</param>
    /// <param name="action">The action to invoke.</param>
    /// <param name="param">The parameter of the action.</param>
    public static void InvokeAction<T>(this Control control, Action<T> action, T param)
    {
        control.Invoke(action, param);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <param name="control">The control to invoke the action on.</param>
    /// <param name="action">The action to invoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    public static void InvokeAction<T1, T2>(this Control control, Action<T1, T2> action, T1 param1, T2 param2)
    {
        control.Invoke(action, param1, param2);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the action.</typeparam>
    /// <param name="control">The control to invoke the action on.</param>
    /// <param name="action">The action to invoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    /// <param name="param3">The third parameter of the action.</param>
    public static void InvokeAction<T1, T2, T3>(this Control control, Action<T1, T2, T3> action, T1 param1, T2 param2, T3 param3)
    {
        control.Invoke(action, param1, param2, param3);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the action.</typeparam>
    /// <typeparam name="T4">The type of the forth parameter of the action.</typeparam>
    /// <param name="control">The control to invoke the action on.</param>
    /// <param name="action">The action to invoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    /// <param name="param3">The third parameter of the action.</param>
    /// <param name="param4">The forth parameter of the action.</param>
    public static void InvokeAction<T1, T2, T3, T4>(this Control control, Action<T1, T2, T3, T4> action, T1 param1, T2 param2, T3 param3, T4 param4)
    {
        control.Invoke(action, param1, param2, param3, param4);
    }
    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to BeginInvoke the function on.</param>
    /// <param name="func">The function to BeginInvoke.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeFunc<TResult>(this Control control, Func<TResult> func)
    {
        return control.BeginInvoke(func);
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to BeginInvoke the function on.</param>
    /// <param name="func">The function to BeginInvoke.</param>
    /// <param name="param1">The parameter of the action.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeFunc<T1, TResult>(this Control control, Func<T1, TResult> func, T1 param1)
    {
        return control.BeginInvoke(func, param1);
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to BeginInvoke the function on.</param>
    /// <param name="func">The function to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeFunc<T1, T2, TResult>(this Control control, Func<T1, T2, TResult> func, T1 param1, T2 param2)
    {
        return control.BeginInvoke(func, param1, param2);
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to BeginInvoke the function on.</param>
    /// <param name="func">The function to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <param name="param3">The third parameter of the function.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeFunc<T1, T2, T3, TResult>(this Control control, Func<T1, T2, T3, TResult> func, T1 param1, T2 param2, T3 param3)
    {
        return control.BeginInvoke(func, param1, param2, param3);
    }

    /// <summary>
    /// Executes the specified function (<paramref name="func"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the function.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the function.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the function.</typeparam>
    /// <typeparam name="T4">The type of the forth parameter of the function.</typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    /// <param name="control">The control to BeginInvoke the function on.</param>
    /// <param name="func">The function to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the function.</param>
    /// <param name="param2">The second parameter of the function.</param>
    /// <param name="param3">The third parameter of the function.</param>
    /// <param name="param4">The forth parameter of the function.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeFunc<T1, T2, T3, T4, TResult>(this Control control, Func<T1, T2, T3, T4, TResult> func, T1 param1, T2 param2, T3 param3, T4 param4)
    {
        return control.BeginInvoke(func, param1, param2, param3, param4);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <param name="control">The control to BeginInvoke the action on.</param>
    /// <param name="action">The action to BeginInvoke.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeAction(this Control control, Action action)
    {
        return control.BeginInvoke(action);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T">The type of the parameter.</typeparam>
    /// <param name="control">The control to BeginInvoke the action on.</param>
    /// <param name="action">The action to BeginInvoke.</param>
    /// <param name="param">The parameter of the action.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeAction<T>(this Control control, Action<T> action, T param)
    {
        return control.BeginInvoke(action, param);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <param name="control">The control to BeginInvoke the action on.</param>
    /// <param name="action">The action to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeAction<T1, T2>(this Control control, Action<T1, T2> action, T1 param1, T2 param2)
    {
        return control.BeginInvoke(action, param1, param2);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the action.</typeparam>
    /// <param name="control">The control to BeginInvoke the action on.</param>
    /// <param name="action">The action to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    /// <param name="param3">The third parameter of the action.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeAction<T1, T2, T3>(this Control control, Action<T1, T2, T3> action, T1 param1, T2 param2, T3 param3)
    {
        return control.BeginInvoke(action, param1, param2, param3);
    }

    /// <summary>
    /// Executes the specified action (<paramref name="action"/>) on the thread that owns the control's underlying window handle.
    /// </summary>
    /// <typeparam name="T1">The type of the first parameter of the action.</typeparam>
    /// <typeparam name="T2">The type of the second parameter of the action.</typeparam>
    /// <typeparam name="T3">The type of the third parameter of the action.</typeparam>
    /// <typeparam name="T4">The type of the forth parameter of the action.</typeparam>
    /// <param name="control">The control to BeginInvoke the action on.</param>
    /// <param name="action">The action to BeginInvoke.</param>
    /// <param name="param1">The first parameter of the action.</param>
    /// <param name="param2">The second parameter of the action.</param>
    /// <param name="param3">The third parameter of the action.</param>
    /// <param name="param4">The forth parameter of the action.</param>
    /// <returns>An System.IAsyncResult that represents the result of the operation.</returns>
    public static IAsyncResult BeginInvokeAction<T1, T2, T3, T4>(this Control control, Action<T1, T2, T3, T4> action, T1 param1, T2 param2, T3 param3, T4 param4)
    {
        return control.BeginInvoke(action, param1, param2, param3, param4);
    }
}

Usem-nos e necessitarem.

Oferta De Licenças Do .NET Reflector

Paulo Morgado — Sun, 17 Apr 2011 23:19:00 Z

A Red Gate deu-me algumas licenças do .NET Reflector para distribuir.

Os primeiros a responder a esta entrada em qualquer dos meus blogues com uma frase acerca do .NET Reflector, nome e e-mail de contacto ganham uma licença grátis.

Despachem-se! Já não há muitas!

Actualização: Já foram atribuídas todas as licenças.