Paulo Morgado

Outras Formas De Fazer Com Que PathInfo E ASP.NET Themes Coexistam

Paulo Morgado — Fri, 25 Jul 2008 00:24:33 GMT

Na minha última entrada apresentei uma solução para os problemas que ocorrem quando tentamos usar path infos em conjunto com ASP.NET Themes and Skins.

O Raj Kaimal sugeriu reescrever os URLs de todos os elementos HTML LINK de forma a que fossem correctamente vistos pelo cliente. Algo como isto:

void HttpApplicationPreRequestHandlerExecute(object sender, System.EventArgs e)
{
    var httpApplication = sender as System.Web.HttpApplication;

    var httpContext = httpApplication.Context;

    var page = httpContext.CurrentHandler as System.Web.UI.Page;

    if ((page != null) && !string.IsNullOrEmpty(httpContext.Request.PathInfo))
    {
        page.PreRenderComplete += delegate(object source, System.EventArgs args)
        {
            var p = source as System.Web.UI.Page;

            foreach (System.Web.UI.Control headerControl in p.Header.Controls)
            {
                var link = headerControl as System.Web.UI.HtmlControls.HtmlLink;
                if (link != null)
                {
                    link.Href = p.ResolveUrl(link.Href);
                }
            }
        };
    }
}

Com esta aproximação persiste ainda o problema (que a minha aproximação não resolvia) com post backs porque o URL contido no atributo ACTION FORM HTML também tem os seus probelmas.

O Israel Aéce sugeriu a utilização do elemento HTML BASE para redefinir a base dos URLs relativos. Algo como isto:

void HttpApplicationPreRequestHandlerExecute(object sender, System.EventArgs e)
{
    var httpApplication = sender as System.Web.HttpApplication;

    var httpContext = httpApplication.Context;

    var page = httpContext.CurrentHandler as System.Web.UI.Page;

    if ((page != null) && !string.IsNullOrEmpty(httpContext.Request.PathInfo))
    {
        page.PreRenderComplete += delegate(object source, System.EventArgs args)
        {
            page.Init += delegate(object source, System.EventArgs args)
            {
                var p = source as System.Web.UI.Page;

                var htmlBase = new System.Web.UI.WebControls.WebControl(System.Web.UI.HtmlTextWriterTag.Base);
                htmlBase.Attributes.Add("href", p.Request.Url.GetLeftPart(System.UriPartial.Authority) + p.Request.CurrentExecutionFilePath);
                p.Header.Controls.Add(htmlBase);
            };
        };
    }
}

Esta parece ser a melhor solução excepto se o vosso site estiver por detrás de vários perímetros e de segurança e não for possível determinar com certeza qual o domínio tal como é visto do lado do cliente, que era o meu problema.

Mas se estão a pensar chamar Server.Execute, Server.TransferRequest ou Server.TransferRequest, nenhuma destas soluções funcionará.

Fazendo Com Que PathInfo E ASP.NET Themes Coexistam

Paulo Morgado — Thu, 24 Jul 2008 00:23:24 GMT

Na minha última entrada escrevi acerca dos problemas que ocorrem quando tentamos usar path infos em conjunto com ASP.NET Themes and Skins.

Mas, tal como na maioria das vezes, não estamos interessados no porque não podemos. Apenas queremos saber como podemos.

Na minha opinião, a forma correcta de o fazer seria usar URLs referenciados a partir da raíz.

Mas como não o podemos fazer, a segunda melhor hipótese será servir correctamente os pedidos erradamente endereçados.

Mas, como o poderemos fazer?

A única solução que arranjei foi um Módulo HTTP:

public class AppThemesModule : global::System.Web.IHttpModule
{
    private static int searchStartIndex = System.Web.HttpRuntime.AppDomainAppVirtualPath.Length;

    #region IHttpModule Members

    public void Dispose()
    {
    }

    public void Init(System.Web.HttpApplication context)
    {
        context.BeginRequest += HttpApplicationBeginRequest;
    }

    #endregion

    void HttpApplicationBeginRequest(object sender, System.EventArgs e)
    {
        System.Web.HttpApplication httpApplication = sender as System.Web.HttpApplication;

        string path = httpApplication.Request.Path;
        if (path.Length > searchStartIndex)
        {
            int appThemesStartIndex = path.IndexOf("/App_Themes/", searchStartIndex);
            if (appThemesStartIndex > 0)
            {
                httpApplication.Context.RewritePath("~" + path.Substring(appThemesStartIndex));
            }
        }
    }
}

Além de registar o móduilo será necessário configurar o directório virtual para que os pedidos para conteúdos a serem servidos dos temas sejam tratados por um StaticFileHandler.

PathInfo E Temas ASP.NET: Porque Não Conseguem Coexistir?

Paulo Morgado — Wed, 23 Jul 2008 22:54:34 GMT

Se já trabalharam com ASP.NET Themes and Skins, sabem que são adicionadas referências para stylesheets na secção head do documento HTML.

O URL gerado para estas stylesheets é sempre relativo.

Ou seja, para um pedido para:

http://MySite/Section/Default.aspx

obtemos:

que faz com que o web browser faça um pedido para:

http://MySite/App_Themes/Default/Styles.css

e tudo funciona às mil maravilhas.

Bem, tudo funciona às mil maravilhas até que se faça um pedido para:

http://MySite/Section/Default.aspx/PathInfo

Obtemos as mesmas referências para stylesheets e o web browser fará um pedido para:

http://MySite/Section/Default.aspx/App_Themes/Default/Styles.css

Isto acontece porque o web browser não tem qualquer conhecimento do que são PathInfos. Apenas sabe quantos separadores (/) existem.

Introduzi um bug no Microsoft Connect acerca disto.

Tornem A Classe HttpValueCollection Pública E Movam-na Para System.DLL

Paulo Morgado — Tue, 15 Jul 2008 00:33:57 GMT

Eu acho a classe System.Web.HttpValueCollection muito útil num vasto número de situações que envolvem a composição de pedidos HTTP ou qualquer outra necessidade e representar uma colecção de pares nome/valor como uma cadeia de caracteres (num atributo XML, por exemplo).

Actualmente (.NET Framework 3.5 SP1 Beta), a única forma de criar uma instância da classe System.Web.HttpValueCollection é usando o método System.Web.HttpUtility.ParseQueryString.

Eu gostaria que esta classe fosse pública e estivesse numa assembly mais genérica como a System.DLL para estar disponível para qualquer tipo de aplicação .NET (aplicações Windows Client, aplicações Windows Service, aplicações Silverlight, aplicações Windows Mobile, etc.).

Se concordam comigo, votem na minha sugestão no Microsoft Connect.

CUIDADO: A Interpretação Feita Pela Classe System.Web.HttpValueCollection Não É Reversível

Paulo Morgado — Mon, 14 Jul 2008 14:01:00 GMT

Se executarem este código:

System.Collections.Specialized.NameValueCollection queryString = System.Web.HttpUtility.ParseQueryString("noKey&=emptyKey&A=Akey");

queryString será, na verdade, uma referência para uma instância do tipo System.Web.HttpValueCollection.

O que esta classe tem de bom é que o resultado da chamada ao método ToString é o conteúdo da colecção devidamente codificado e formatado para ser usado num URL.

Tal como acontece com a classe base (NameValueCollection), há uma diferença entre a chave ser uma cadeia (string) nula ou uma cadeia vazia na forma como é feita a interpretação da cadeia de entrada. Uma cadeia nula corresponde a não ser especificado parâmetro e uma cadeia vazia corresponde a ser especificado um parâmetro cujo nome é uma cadeia vazia.

Sendo assim, quando se chama ToString numa instância retornada pelo método System.Web.HttpUtility.ParseQueryString espera-se obter a cadeia de entrada (ou, pelo menos, uma que, quando interpretada, dê origem a uma colecção equivalente), certo? Na verdade, o que se obtém é isto: noKey&emptyKey&A=Akey.

Reportei este erro no connect. Se acham que é importante e deve ser corrigido, votem.

SAPO Summerbits, 1ª Edição

Paulo Morgado — Wed, 09 Jul 2008 00:48:07 GMT

Está aí o SAPO Summerbits, 1ª Edição.

O programa "SAPO Summerbits” é inspirado no Google Summer of Code, onde são oferecidas bolsas a estudantes, de todos os graus de ensino ou proveniências (maiores de 18 anos e com vínculo a escola/universidade portuguesa), para que desenvolvam código para projectos de software livre, já existentes ou completamente novos. O SAPO, com o apoio de outras entidades, seleccionará as ideias com maior impacto tecnológico e social, financiando o seu desenvolvimento ao longo de três meses. A ambição do SAPO Summerbits é, acima de tudo, a de se tornar um programa de referência no meio académico português, mostrando ao mundo toda a capacidade criativa dos nossos estudantes.

Lançamento do Isolator 4.3

Paulo Morgado — Wed, 02 Jul 2008 22:30:35 GMT

Hoje, a Typemock lançou a versão 4.3 do Typemock Isolator. Descarreguem daqui.

O que há de novo?

Suporte para Ivonna. Para quem desenvolve aplicações ASP.NET, o Ivonna é uma grande ferramenta, suportada pela plataforma Isolator, para simplificar a escrita de testes para ASP.NET.
Adição e APIs do namespace Typemock.Integration.Packs para gestão de licenças através do Isolator, como usa o Ivonna.
Tal como tinha sido anunciado quando foi lançada, a versão 4.2 foi a última a suportar .NET 1.1. A versão 4.3 suporta apenas o ambiente de execução 2.0 e respectivas versões de Visual Studio: VS2005 e VS2008.
Para máquinas de 64 bit, agora existe apenas um instalador. (não esquecer desinstalar ambas as versões anteriores (32 e 64 bit) antes de instalar a versão 4.3.)
RecorderManager.GetMockOf(instanceRef) e MockManager.GetMockOf(instanceRef). Para o objecto controlador do objecto simulado (mock) a partir de uma instância de objecto simulado. (mais...).

Problemas resolvidos:

Problemas no suporte a DLINQ resolvidos.
Os construtores estáticos já são invocados correctamente quando se usa Natural Mocks.
Resolvido o problema em que era lançada uma excepção quando se simulavam interfaces ("Method XX in type IMyInterface has no matching overload that returns TypeMock.Mock+a).
Resolvido o problema em que era lançada uma excepção quando o objecto simulado sobrepunha uma implementação de Equals.
Resolvido o problema que causava falhas na simulação de implementação explicita de interface com o mesmo nome.
Resolvido o problema com VerifyWithWait em cenários de multithreading.
Resolvido o problema em que era lançada uma NullReferenceException quando se usava Auto Deploy.

Mais informações:

Recebi O Prémio Microsoft MVP Pela 6ª Vez E: I FEEL GREAT

Paulo Morgado — Tue, 01 Jul 2008 22:31:41 GMT

Video: I Feel Great! - MVP

Porquê Usar Valores Aleatórios Para Testes Unitários

Paulo Morgado — Mon, 30 Jun 2008 00:38:15 GMT

Numa entrada anterior mencionei a minha biblioteca para geração de valores aleatórios para efeitos de testes unitários.

Recebi alguns comentários e questões interessantes nos meus blogues [^][^][^][^].

O Simon diz que ele “geralmente quer que cada instância do teste que corre seja repetível em *todas* as execuções” e está “inclinado a usar a funcionalidade de fonte de dados do VSTS Unit Tests”. Eu não podia estar mais de acordo.

O Hugo indicou-me o Pex. Parece interessante. Tenho de ver melhor isto.

Alguns comentários mostravam alguma preocupação para, no caso do teste falhar, não ser possível reproduzir as condições do teste e por isso não seria possível perceber a razão da falha do teste. Na minha opinião, todos os dados usados num teste que falha devem estar no relatório do teste (pelo menos, os dados que fizeram o teste falhar). Quer os dados sejam previsíveis ou aleatórios.

Acho que a maioria dos comentários “contra” a minha ideia se deveram ao facto de não a ter explicado bem. Vou tentar fazer melhor agora.

Eu uso estes valores aleatórios quando o valor em si não é importante, apenas o facto de ser único.

Imagine-se uma classe Cliente em que para dizer que duas instâncias se referem ao mesmo cliente é suficiente comparar o seu ID. Para testar o código e comparação não necessito nenhum conjunto reprodutível de dados. Apenos preciso que sejam difrentes ou mesmo, dependendo do teste.

Imagine-se que se está a testar código de acesso a base de dados com uma connection string de um elemento específico de connection string settings. Não é importante saber qual o conteúdo da connection string porque não se vai realmente aceder à base ded dados (isto é muito fácil de fazer com o Isolator).

Espero ter-me explicado melhor desta vez.

Substituindo Assemblies Carregadas

Paulo Morgado — Sun, 29 Jun 2008 21:53:29 GMT

Recentemente perguntaram-me se era possível substituír as assemblies carregadas por uma aplicação Windows Service implementada em .NET enquanto esta corre, como o ASP.NET. Tal como no ASP.NET, eventos de início e de fifinalização da aplicação eram necessários.

A solução até é simples. A aplicação Windows Service passa a ser apenas um carregador que não tem qualquer referência para as assemblies carregadas que poderão sofrer alterações e ter uma assembly com um ponto de entrada que funciona como o evento de início. Esta assembly deve ser carregada num novo AppDomain com ShadowCopyFiles definido como true. O evento de finalização é tratado tratando o evento DomainUnload do AppDomian onde as assemblies a correr foram carregadas.

Se se quiser que a assembly a correr, assim como as assemblies por esta referenciadas sejam descarregadas e novamente carregadas quando ocorre uma modificação nos ficheiros destas assemblies, pode-se recorrer a um FileSystemWatcher, embora eu preferisse anular este comportamento no ASP.NET, não copiá-lo.

O carregador pode ser algo tão simples como isto:

class Program
{
    private static Thread thread = null;
    private static AppDomain appDomain = null;

    static void Main(string[] args)
    {
        while (true)
        {
            Console.WriteLine();
            Console.WriteLine("Options:");
            if (appDomain == null)
            {
                Console.WriteLine("    L - Load");
            }
            else
            {
                Console.WriteLine("    U - Unload");
            }
            Console.WriteLine("    X - Exit");

            switch (Console.ReadKey().KeyChar)
            {
                case 'l':
                case 'L':
                    thread = new Thread(Load);
                    thread.Name = "Runner";
                    thread.Start(args);
                    while (appDomain == null) ;
                    break;
                case 'u':
                case 'U':
                    Unload();
                    break;
                case 'x':
                case 'X':
                    Unload();
                    return;
            }
        }
    }

    private static void Load(object obj)
    {
        string[] args = obj as string[];

        AppDomainSetup appDomainSetup = new AppDomainSetup();
        appDomainSetup.ApplicationBase = args[0];
        appDomainSetup.PrivateBinPath = args[0];
        appDomainSetup.ShadowCopyFiles = "true";

        appDomain = AppDomain.CreateDomain("Runner", AppDomain.CurrentDomain.Evidence, appDomainSetup);

        appDomain.ExecuteAssemblyByName("ConsoleApplication", AppDomain.CurrentDomain.Evidence, new string[0]);
    }

    private static void Unload()
    {
        AppDomain.Unload(appDomain);
        appDomain = null;
        thread = null;
    }
}

O carregador recebe o caminho para a pasta onde estão as assemblies a carregar e o nome da assembly a correr.

A assembly a correr pode ser algo com isto:

class Program
{
    static readonly DateTime dateTime = DateTime.Now;

    static void Main(string[] args)
    {
        AppDomain.CurrentDomain.DomainUnload += delegate
        {
            Console.WriteLine();
            Console.WriteLine("Unloading: {0}", dateTime);
        };

        System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();

        Console.WriteLine("Loading: {0}", dateTime);
        Console.WriteLine("Assembly: {0}", assembly.FullName);
        Console.WriteLine("Location: {0}", assembly.Location);

        FileInfo fileInfo = new FileInfo(assembly.Location);
        Console.WriteLine("Location Dates: CreationTime={0}, LastWriteTime={1}, LastAccessTime={2}",
            fileInfo.CreationTime, fileInfo.LastWriteTime, fileInfo.LastAccessTime);

        while (true)
        {
            Console.Write('.');
            Thread.Sleep(100);
        }
    }
}

Com este “sistema” pode-se carregar ou descarregar e substituír as assemblies que estão a correr quando se quiser.