Category Archive

Depois de terminadas as férias (incluindo as férias mentais), está na altura de recomeçar a escrever sobre coisas mais técnicas, como os plugins.

O próximo passo vai permitir que o primeiro grande objectivo se aproxime: permitir que os plugins adicionem elementos à interface usando a ‘Shell’, que representa a aplicação vista pelos olhos dos plugins. A partir desta classe vai ser possível adicionar elementos aos forms, abrir novos documentos, lançar eventos para outros plugins, etc:

Read the rest of this entry »

Hoje a ler a revista MSDN online reparei num artigo que fala sobre implementar I/O assíncrono usando delegados para os callbacks. Imediatamente lembrei-me do projecto que fiz na Inosat, em que para conseguir rede, GPS ou GRPS no dispositivo móvel, usei um sistema parecido com este.

A maior diferença é que, em vez de declarar dois métodos para callback – um em caso de sucesso e outro em caso de falha – usei apenas um, retornando sempre um valor do tipo Result<T>. Por exemplo, se virem no artigo, o autor para o método:

   1: public static string ReadAllText(string path);

define a seguinte assinatura:

   1: public static void ReadAllTextAsync(string path, Action<string> success, Action<Exception> failure);

em que o primeiro método é chamado se o método correr como esperado, o segundo é invocado se houver algum problema pelo caminho. No meu caso, a definição seria algo como:

   1: public static void ReadAllTextAsync(string path, Result<string> success);

em que a classe Result é:

   1: public class Result<T>

   2: {

   3:     private readonly T _value;

   4:     private readonly bool _valid;

   5:     private readonly string _error;

   6:  

   7:     private Result(T value)

   8:     {

   9:         _value = value;

  10:         _valid = true;

  11:     }

  12:  

  13:     private Result(string error) : this()

  14:     {

  15:         _error = error;

  16:     }

  17:  

  18:     private Result()

  19:     {

  20:         _valid = false;

  21:     }

  22:  

  23:     public static Result<T> Failed()

  24:     {

  25:         return new Result<T>();

  26:     }

  27:  

  28:     public static Result<T> Failed(string error)

  29:     {

  30:         return new Result<T>(error);

  31:     }

  32:  

  33:     public static Result<T> Success(T value)

  34:     {

  35:         return new Result<T>(value);

  36:     }

  37:  

  38:     public T Value

  39:     {

  40:         get { return _value; }

  41:     }

  42:  

  43:     public bool Valid

  44:     {

  45:         get { return _valid; }

  46:     }

  47:  

  48:     public string Error

  49:     {

  50:         get { return _error; }

  51:     }

  52: }

Isto permite que o Result seja usado para notificar se o método teve sucesso ou não e, caso não tenha, que se possa passar o erro que se encontrou.

A diferença que encontro nas duas abordagens é que, no meu caso, quem trata do resultado tem de verificar se a operação teve sucesso chamando o result.Valid. No caso da implementação que está na revista, cada método sabe se o resultado teve sucesso ou não. Para os puristas que defendem a abolição do uso de If’s (já trabalhei com alguns ), isto é puro ouro!

O primeiro problema que tenho de enfrentar para conseguir usar um sistema de plugins é conseguir identificar os plugins que temos disponíveis e os inicializar. Para isso vou criar o PluginManager.

De alguma forma tenho de definir como é que os plugins serão descobertos pela aplicação: Lidos automaticamente de uma directoria pré-definida, previamente registados usando uma UI na aplicação, ficheiros de configuração, etc. Como não quero ter de decidir isso para já, vou implementar a forma mais fácil que me consiga lembrar e, tendo o cuidado de não ter o uso desta implementação especifica ‘hard-coded’ em lugar algum, vou permitir que mais tarde se possa mudar o plugin manager (quem sabe usando.. um plugin!)

Read the rest of this entry »

Para o projecto em que estou envolvido desde Janeiro, desde cedo fiz questão que fossem usados muitos processos relacionados com o desenvolvimento para, no final, facilitar o processo de manutenção.

No top 3 destes processos estão, sem qualquer sombra de dúvida:

• Uso de source control (SVN)
• Integração contínua
• Log4net

Desde que usei o log4net na Inosat que acho que é uma ferramenta indispensável para a grande maioria* dos programadores. Desde que a aplicação foi instalada nos servidores que, invariavelmente, todos os problemas podem ser identificados usando os logs para verificar o que se passou.

Read the rest of this entry »

Ultimamente tenho andado a trabalhar num pequeno projecto pessoal que entretanto decide partilhar.

O objectivo deste projecto é fazer uma aplicação semelhante ao Outlook em termos de interface mas, em vez de tratar de emails, esta aplicação seria direccionada para… qualquer coisa.

Read the rest of this entry »

Ao ler o blog do Tiago vi uma solução que ele colocou para encontrar a parte decimal de um número usando C#.

À primeira vista pareceu-me que a solução dele era um pouco ingénua:

   1: public static int GetDecimalPart(double value)

   2: {

   3:     int number = (int) value;

   4:     string numbString = number.ToString();

   5:     int stringLength = numbString.Length;

   6:     return Int32.Parse(value.ToString().Substring(stringLength + 1));

   7: }

Quer dizer, usar strings e Lenght’s? :S Não me parece que seja bom… Então decidi tentar fazer melhor … Esta foi a minha primeira iteração:

Read the rest of this entry »