Como usar provedores de caminho virtual para carregar dinamicamente e compila o conteúdo de caminhos virtuais no ASP.NET 2.0

Saudação e de volta bem-vindo! Meu nome é Parag Agarwal, um engenheiro de suporte da Microsoft. Este mês, vamos abordar provedores de caminho virtual no Microsoft ASP.NET 2.0.

Visão geral

Este mês, discutiremos como estender o ASP.NET fornecendo virtual acesso a conteúdo e arquivos para compilação no ASP.NET 2.0. Esse recurso pode ser usado para criar aplicativos semelhante ao Microsoft SharePoint Portal Server, onde o conteúdo é armazenado em um banco de dados em vez de no sistema de arquivo físico. Neste artigo, irá criamos um exemplo onde o conteúdo da página de formulário da Web solicitada está armazenado em um banco de dados do Microsoft SQL Server.

Provedor de caminho virtual

Um provedor de caminho virtual fornece um mecanismo com o qual pode estendemos ASP.NET para servir conteúdo virtual para o sistema de compilação. Por exemplo, um provedor de caminho virtual fornece um meio para fornecer conteúdo de locais sejam o sistema de arquivos. Os desenvolvedores que desejam fornecer conteúdo virtual devem realizar as seguintes tarefas:

• Criar uma classe VirtualPathProvider e implementar todos os métodos necessários para manipular arquivos e solicitações de pasta.
• Registrar o provedor de caminho virtual para permitir que o ambiente de hospedagem do ASP.NET sabe onde o conteúdo será disponibilizado.
• Criar objetos VirtualFile e VirtualDirectory para transmitir o conteúdo.

Para obter mais informações sobre a classe VirtualPathProvider , visite o seguinte site da Web Microsoft Developer Network (MSDN):

O conteúdo pode ser virtualizado?

Tipos navegáveis, como ASPX, páginas mestras, ASCX e temas, são os únicos itens que podem ser virtualizados.

O aplicativo é inicializado depois de chamadas feitas para o método estático AppInitialize e eventos que são definidos dentro do arquivo global.asax . Essas chamadas de método são apenas duas casas onde a classe VirtualPathProvider pode ser registrada.

A compilação de nível superior itens, como as pastas App_Code e App_Data, não pode ser afetada em qualquer ponto no ciclo de vida do aplicativo para o provedor que você deseja registrar.

Para virtualizar conteúdo navegável não-padrão, você precisa mapear uma classe de BuildProvider . Para obter mais informações sobre a classe BuildProvider e como o ASP.NET criar ambiente usa a classe BuildProvider para gerar o código fonte para diferentes tipos de arquivo, visite o seguinte site da MSDN:

Modelo de compilação

Antes de criarmos uma amostra para provedores de caminho virtual, veremos uma visão geral dos principais componentes no modelo de compilação do ASP.NET 2.0. Esta visão geral o ajudará a compreender como o conteúdo é compilado pelo sistema de compilação ASP.NET, abra e criando o site no Microsoft Visual Studio para procurar uma página da Web.

A classe ClientBuildManager

A classe ClientBuildManager oferece APIs para criação de módulos (assemblies), gerando o código-fonte e executar pré-compilação interagindo com o ASP.NET criar sistema. A classe ClientBuildManager fornece acesso ao sistema de compilação fora do Microsoft Internet Information Services (IIS). Usando a classe ClientBuildManager , o Visual Studio 2005 oferece recursos interessantes, como IntelliSense, conclusão da instrução e relatório de erros em tempo real. A classe ClientBuildManager também fornece caminhos virtuais e físicos para o arquivo ou arquivos. Para obter mais informações, visite o seguinte site da MSDN:

A classe BuildManager

A classe BuildManager gerencia o processo de compilar assemblies e páginas no aplicativo. Para obter mais informações, visite o seguinte site da MSDN:

A classe BuildProvider

A classe BuildProvider fornece funcionalidade para analisar um arquivo específico e gerar o código correspondente do arquivo. Para obter mais informações, visite o seguinte site da MSDN:

A classe AssemblyBuilder

A classe AssemblyBuilder representa um assembly dinâmico com uma lista de todas as dependências de assembly. Essa classe espera código-fonte ou um objeto de CodeCompileUnit fornecido pelo provedor de compilação durante o processo de compilação. Para obter mais informações, visite o seguinte site da MSDN:

Estendendo o caminho virtual provedores para servir conteúdo virtual provenientes de um banco de dados

Agora que temos uma compreensão geral de provedores de caminho virtual e o modelo de compilação, podemos criar um portal do SharePoint pequeno aplicativo semelhantes a serviços que fornece acesso a conteúdo não baseado em arquivo.

Observação Antes de começarmos a criar o aplicativo de exemplo, vamos examine a estrutura de banco de dados e a hierarquia de site usada no exemplo:

Há apenas uma tabela que é chamada VirtualFileSystem no banco de dados. Esta tabela é semelhante ao seguinte:

Hierarquia do site dentro do Visual Studio é semelhante ao seguinte:


anotações

• A pasta App_Code contiver todas as classes necessárias para implementar um provedor de caminho virtual, como a classe VirtualPathProvider , a classe VirtualDirectory , a classe VirtualFile e uma classe de utilitário .
• A pasta SharePointDir representa um diretório virtual. O conteúdo deste diretório virtual é armazenado no banco de dados. Qualquer solicitação para uma página dentro dessa pasta será considerada como uma solicitação para um arquivo virtual pelo runtime do ASP.NET.
• A página AdminstrationPage.aspx exibe uma interface do usuário onde podemos pode executar CRUD (Create, Read, Update e DELETE) operações no conteúdo virtual com a Ajuda de um controle GridView . Página AdminstrationPage.aspx é semelhante ao seguinte:

Vamos começa a criar o exemplo.

Para fazer isso, execute as seguintes etapas:

1. Inicie o Visual Studio 2005.
2. Crie um site que tem a hierarquia exata e arquivos que aparecem na imagem anterior.
3. Abra o arquivo de origem SharePointDirectory.cs.
4. Verifique se os namespaces a seguir estão incluídos no arquivo SharePointDirectory.cs:

   using System;
   using System.Collections;
   using System.Data;
   using System.Security.Permissions;
   using System.Web;
   using System.Web.Hosting;
   

5. Declarar uma classe SharePointProvider e herdam class. VirtualPathProvider

   public class SharePointProvider : 
   VirtualPathProvider

6. Declare duas members.

   //It contains the file name and content as a key-value pair retrieved 
   //from the database.
   Hashtable virtualFiles = null; 
   DBUtility utility = null;

7. Adicione o método AppInitialize . O método AppInitialize é o método mais importante nesse processo. O ASP.NET mecanismo de tempo de execução chama esse método quando o aplicativo é inicializado.
   
   Observação Esse método pode ser considerado como um truque onde podemos fazer o runtime do ASP.NET carregar esta classe sem qualquer arquivo Web.config.
   
   Se temos mais de uma classe com esse método, ocorrerá um erro de compilação. Dentro desse método, são registrando nosso provedor com o ambiente de hospedagem do ASP.NET. Agora, cada solicitação para uma página da Web irá passar por esse provedor.

   public static void AppInitialize()
   {
      HostingEnvironment.RegisterVirtualPathProvider(new SharePointProvider());
   }

8. Implemente o construtor para a classe SharePointProvider . Essa etapa é onde podemos irá recuperar todos os arquivos virtuais e o seu conteúdo na memória para acesso rápido. Até que o conteúdo é invalidado, usaremos o conjunto de resultados na memória. Assim que o conteúdo é alterado no banco de dados, o conteúdo precisa ser atualizado.

   public SharePointProvider(): base() 
   {
      utility = new DBUtility();
      virtualFiles = utility.GetVirtualFiles();
   }

9. Em seguida, adicione o método IsPathVirtual . Usando esse método, podemos determinar se o arquivo solicitado é de um caminho virtual. Já decidimos que arquivo solicitado dentro da pasta SharePointDir será considerado como um arquivo virtual.

   private bool IsPathVirtual(string virtualPath)
   {
      String checkPath = 
         VirtualPathUtility.ToAppRelative(virtualPath);
      return checkPath.StartsWith("~/SharePointDir".ToLower().ToString(), StringComparison.InvariantCultureIgnoreCase);    
   }

10. O método FileExists retorna se o arquivo existe. Ele faz isso verificando que o arquivo solicitado existe no banco de dados. Se o arquivo não existir, irá obter a referência do objeto de provedor de caminho virtual registrado anteriormente no sistema de compilação e nós tentará localizar o arquivo novamente, chamando o método FileExists . Se o arquivo ainda não for encontrado, receberemos outro "404 (arquivo não encontrado)" mensagem de erro.

    public override bool FileExists(string virtualPath)
    {
             if (IsPathVirtual(virtualPath))
             {
                SharePointVirtualFile file = (SharePointVirtualFile)GetFile(virtualPath);
                // Determine whether the file exists on the virtual file 
                // system.
                if (utility.CheckIfFileExists(virtualPath))
                    return true;
                else
                    return Previous.FileExists(virtualPath);
              }
              else
              return Previous.FileExists(virtualPath);
     }

11. Da mesma forma, temos o método DirectoryExists . Este método retornará true se o provedor pode atender o caminho de arquivo virtual que é passado como um argumento. Caso contrário, o provedor fornecerá o caminho do arquivo virtual do provedor registrado anteriormente como de costume e nós receberá mensagens de erro 404 novamente se a pasta não existir.

    public override bool DirectoryExists(string virtualDir)
    {
       if (IsPathVirtual(virtualDir))
       { 
          // Right now, we are not storing the directory information in  
          // our SharePoint Portal Services database. We assume that all of the virtual 
          // content is served from a directory that is named SharePointDir and was
          // created inside the ASP.NET Web site. Therefore, we will always 
          // return TRUE in this case.	
          SharePointVirtualDirectory dir = (SharePointVirtualDirectory)GetDirectory(virtualDir);
          return true;
       }
       else
          return Previous.DirectoryExists(virtualDir);
     }

12. Em seguida, temos os métodos GetFile e GetDirectory . O runtime do ASP.NET chama esses métodos no provedor de caminho virtual após as chamadas para FileExists e DirectoryExists métodos são bem-sucedidas.

    //This method is used by the compilation system to obtain a VirtualFile instance to 
    //work with a given virtual file path.
    public override VirtualFile GetFile(string virtualPath)
    {
       if (IsPathVirtual(virtualPath))
          return new SharePointVirtualFile(virtualPath, this);
       else
          return Previous.GetFile(virtualPath);
    }
    
    //This method is used by the compilation system to obtain a VirtualDirectory 
    //instance to work with a given virtual directory.
    public override VirtualDirectory GetDirectory(string virtualDir)
    {
       if (IsPathVirtual(virtualDir))
           return new SharePointVirtualDirectory(virtualDir, this);
       else
           return Previous.GetDirectory(virtualDir);
    }

13. É necessário adicionar alguns métodos de utilitário que serão usados pela classe VirtualFile posteriormente neste exemplo.

    public string GetFileContents(string virPath)
    {
       return utility.GetFileContents(virPath);	
    }
    
    public Hashtable GetVirtualData
    {
       get { return this.virtualFiles; }
       set { this.virtualFiles = value; }
    }

    Observação neste exemplo, nós não estiver usando o mecanismo para notificar o sistema de compilação das alterações feitas no conteúdo virtual. O provedor virtual expõe uma API que é chamada GetCacheDependency usada para cache virtual recursos da Ajuda. Nós pode invalidar o cache quando qualquer um dos arquivos tornam-se inválido. Para obter mais informações, visite o seguinte site da MSDN:
    http://msdn2.microsoft.com/en-us/library/system.web.hosting.virtualpathprovider.getcachedependency.aspx (http://msdn2.microsoft.com/en-us/library/system.web.hosting.virtualpathprovider.getcachedependency.aspx)
14. Terminarmos a classe de provedor principal. Agora abra o arquivo de origem SharePointDirectory.cs. Essa classe servirá como uma abstração para recursos virtualizados. Para obter mais informações sobre a classe VirtualDirectory , visite o seguinte site da MSDN:
    http://msdn2.microsoft.com/en-us/library/system.web.hosting.virtualdirectory.aspx (http://msdn2.microsoft.com/en-us/library/system.web.hosting.virtualdirectory.aspx)
15. Como a classe VirtualDirectory é uma classe abstrata, precisamos substituir todos os métodos abstratos. No entanto, não forneceremos a implementação extra sobre esses métodos substituídos porque nesse exemplo supomos que conteúdo virtual está chegando dentro de um único diretório virtual. Portanto, a definição de classe aparência terá o seguinte:

    public class SharePointVirtualDirectory : VirtualDirectory
    {
       SharePointProvider spp;
       public SharePointVirtualDirectory(string virtualDir, SharePointProvider provider) : base(virtualDir){spp = provider;}
       private ArrayList children = new ArrayList();
       public override IEnumerable Children {get {return children;}}
       private ArrayList directories = new ArrayList();
       public override IEnumerable Directories{get {return directories;}}
       private ArrayList files = new ArrayList();
       public override IEnumerable Files{get { return files;}}
    }

16. Agora, estamos prontos para definir uma classe mais chamado SharePointVirtualFile que amplia a classe abstrata VirtualFile . Essa classe terá um método abstract substituído é chamado OpenFile . O método OpenFile retorna uma instância de fluxo que é usada pelo ASP.NET criar o ambiente para consumir o arquivo virtual.

    public class SharePointVirtualFile : VirtualFile
    {
       private SharePointProvider spp;
       private string virPath;
    
       public SharePointVirtualFile(string virtualPath, SharePointProvider provider) : base(virtualPath)
       {
          this.spp = provider;
          this.virPath = virtualPath;
        }
    
        public override Stream Open()
        {
           string fileContents = spp.GetFileContents(virPath);
           Stream stream = new MemoryStream();
           if (fileContents != null || fileContents.Equals(String.Empty))
           {
               // Put the page content on the stream.
               StreamWriter writer = new StreamWriter(stream);
               writer.Write(fileContents);
               writer.Flush();
               stream.Seek(0, SeekOrigin.Begin);
            }
            return stream;
          }
    }

17. Por último, irá definir a classe DBUtiliity no arquivo DBUtility.cs . A implementação do método não é fornecida. A classe DBUtiliity é usada por classes de provedor para obter o conteúdo do banco de dados juntamente com algumas outras funções de utilitário.

    public class DBUtility
    {
       SqlConnection cnn;
       string connectionString = "connectionstring to DB?";
        
       //Run a select query to obtain all files and their content, and 
       //store the result in a in memory hashtable to obtain fast access.	
       string cmdSelectAllFiles = "SELECT FileName,FileData FROM VirtualFileSystem";
       Hashtable virtualFiles = null;
    
       public DBUtility(){ virtualFiles = new Hashtable();}
    
       public Hashtable GetVirtualFiles()
       {
          /* 1. Open a connection.  
             2. Select all the files.
             3. Iterate through the result and store the file name as a Key and
                content as a Value in a hashtable.
             4. Finally return hashtable.
          */
          return virtualFiles;
        }
    
       public string GetFileContents(string virPath)
       {
          //Obtain a file name from the virtual path. 
          string fileName = ExtractFileName(virPath);
            
          //Ater you obtain the file name, find it in the hashtable, and then
          //return the content for that file from the Values collection.	
        }
    
       private string ExtractFileName(string virPath)
       {
           //Extract a file name from the virtual path and return it.
       }
    
       public bool CheckIfFileExists(string virPath)
       {
           string fileName = ExtractFileName(virPath);
           //After you extract the file name, find it in the hashtable of 
           //virtual files. If the file name is found, return true. Otherwise, return false.	
        }
    }
    

    Observação uma coisa a tenha em mente é que registrar um provedor é uma operação privilegiada, pois ele pode alterar o conteúdo processado. Classes personalizadas para as classes VirtualPathProvider VirtualDirectory e VirtualFile precisam executar em permissões de confiança total . Para obter mais informações, visite o MSDN seguinte site:
    http://msdn2.microsoft.com/en-us/library/system.web.aspnethostingpermission.aspx (http://msdn2.microsoft.com/en-us/library/system.web.aspnethostingpermission.aspx)
18. São fizemos escrever as classes de provedor e agora nosso aplicativo está pronto para servir conteúdo virtual. Para dar o aplicativo a aparência e o comportamento de uma página da Web de administração de portal do SharePoint, criei uma página AdministrationPage.aspx na pasta raiz do site. The page contains a GridView control that is bound with a virtual table.

    <asp:GridView ID="GridView1" runat="server"  
          AutoGenerateColumns="False" DataSourceID="SqlDataSource1" >
        <Columns>
          <asp:BoundField DataField="FileName" HeaderText="FileName" />
          <asp:TemplateField HeaderText="Remote Content" >
            <ItemTemplate>
              <asp:Label ID="Label1" runat="server"  
                         Text="FileContent...."></asp:Label>
            </ItemTemplate>
            <EditItemTemplate>
              <asp:TextBox ID="Label1" runat="server" Text='<%# 
                    Eval("FileData", "{0}") %>'></asp:TextBox>
            </EditItemTemplate>
            </asp:TemplateField>
            <asp:HyperLinkField HeaderText="Virtual Path" 
                 DataTextField="VirtualPath" Target="_self" 
                 DataNavigateUrlFormatString= "{0}"  
                 DataNavigateUrlFields="VirtualPath" />   
            <asp:CommandField  ShowEditButton="True" 
                 ShowDeleteButton="True" CausesValidation="false" 
                 HeaderText="Operations" CancelText="Cancel" />   
       </Columns>
    </asp:GridView>
    <asp:SqlDataSource ID="SqlDataSource1" runat="server" 
                       ConnectionString="<%$ 
        ConnectionStrings:VirtualProviderDBConnectionString %>"
        SelectCommand="SELECT [FileName], [FileData], [VirtualPath] FROM 
        [VirtualFileSystem] Where [FileName] LIKE '%aspx%'?>
    </asp:SqlDataSource>
    

Conclusão

Para provedores de caminho virtual, esse é todos os para agora. Espero que esta coluna o ajudará a compreender o processo de compilação básico para ASP.NET 2.0 e como nós pode permitir que o runtime do ASP.NET trabalhar com conteúdo com base não do arquivo, como conteúdo servido de um banco de dados.

Obrigado por seu tempo. Esperamos que escrever obter mais informações sobre novos recursos adicionados no ASP.NET 2.0. Para obter mais informações e exemplos, visite os sites da MSDN:

Como sempre, vontade enviar idéias sobre tópicos desejado no futuro abordada colunas ou na Base de dados de Conhecimento usando o formulário Ask For It (http://support.microsoft.com/common/survey.aspx?scid=sw;en;1176&p0=&p1=&p2=&p3=&p4=) .