Como utilizar fornecedores de caminho virtual para carregar dinamicamente e conteúdo de compilação de caminhos virtuais no ASP.NET 2.0

"Hello" e bem-vindo novamente! Meu nome estiver Parag Agarwal, um engenheiro de suporte da Microsoft. Este mês Microsoft vão discutir fornecedores de caminho virtual da Microsoft ASP.NET 2.0.

Descrição geral

Este mês, irá discutem o modo expandir ASP.NET através do fornecimento virtual acesso ao conteúdo e ficheiros para a compilação no ASP.NET 2.0. Esta funcionalidade pode ser utilizada para criar aplicações semelhante à Microsoft SharePoint Portal Server, onde o conteúdo está armazenado numa base de dados em vez de no sistema de ficheiro físico. Neste artigo, a Microsoft irá criar uma amostra onde o conteúdo da página de formulário Web pedida é armazenado na base de dados do Microsoft SQL Server.

Fornecedor de caminho virtual

Um fornecedor de caminho virtual fornece um mecanismo com o qual é possível expandir ASP.NET para servir conteúdo virtual para o sistema de compilação. Por exemplo, um fornecedor de caminho virtual fornece um meio para fornecer conteúdo de localizações diferente do sistema de ficheiros. Programadores que pretendam fornecer conteúdo virtual devem executar as tarefas seguintes:

• Criar uma classe VirtualPathProvider e implementar todos os métodos necessários para processar pedidos de pasta e ficheiros.
• Registar o fornecedor de caminho virtual para permitir que o ASP.NET ambiente de alojamento de saber onde vai ser servido o conteúdo de.
• Crie objectos VirtualFile e VirtualDirectory para transmissão em sequência o conteúdo.

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

O conteúdo que pode ser virtualized?

Tipos browseable, tais como ASPX, páginas principais, ASCX e temas, são os itens únicos que podem ser virtualized.

A aplicação é inicializada após serem efectuadas chamadas para o método estático AppInitialize e eventos que são definidos no ficheiro global.asax . Estas chamadas de método são apenas dois locais onde a classe VirtualPathProvider pode ser registada.

A compilação de itens de nível superior, como pastas App_Code e App_Data, não é afectada em qualquer ponto no ciclo de vida da aplicação para o fornecedor que pretende registar.

Para virtualize conteúdo com procura possível não predefinidas, necessita de mapear uma classe BuildProvider . Para obter mais informações sobre a classe BuildProvider e como o ASP.NET criar ambiente utiliza a classe BuildProvider para gerar código para tipos de ficheiro diferente, visite o seguinte site da Web MSDN:

Modelo de compilação

É criado um exemplo de fornecedores de caminho virtual, irá de virar uma descrição geral dos principais componentes do modelo de compilação do ASP.NET 2.0. Esta visão geral ajudarão compreender como conteúdo é compilado pelo sistema de compilação do ASP.NET, abrir e criar o Web site no Microsoft Visual Studio para procurar uma página Web.

A classe ClientBuildManager

A classe ClientBuildManager oferece API para criar assemblagens, gerar código de origem e efectuar pre-compilation interagindo com o ASP.NET construir o sistema. A classe ClientBuildManager fornece acesso ao sistema compilação fora do Microsoft Internet Information Services (IIS). Utilizando a classe ClientBuildManager , Visual Studio 2005 fornece interessantes funcionalidades tais como o IntelliSense, conclusão de instrução e relato de erros em tempo real. A classe ClientBuildManager também fornece caminhos virtuais e físicos para o ficheiro ou ficheiros. Para mais informações, visite o seguinte site da Web MSDN:

A classe BuildManager

A classe BuildManager gere o processo de compilação de assemblagens e páginas na aplicação. Para mais informações, visite o seguinte site da Web MSDN:

A classe BuildProvider

A classe BuildProvider fornece funcionalidades para analisar um ficheiro em particular e gerar o código correspondente do ficheiro. Para mais informações, visite o seguinte site da Web MSDN:

A classe AssemblyBuilder

A classe AssemblyBuilder representa uma assemblagem dinâmica com uma lista de todas as dependências de assemblagem. Esta classe espera código de origem ou um objecto de CodeCompileUnit fornecido pelo fornecedor de compilação durante um processo de compilação. Para mais informações, visite o seguinte site da Web MSDN:

Expandir fornecedores de caminho virtual para servir conteúdo virtual provenientes de uma base de dados

Agora que temos compreender dos fornecedores de caminho virtual e o modelo de compilação, é possível criar um pequeno SharePoint Portal semelhantes dos serviços de aplicação que fornece acesso a conteúdo não baseado em ficheiros.

Nota Antes de começar é criar a aplicação de exemplo, diga-nos observe a estrutura de base de dados e a hierarquia do Web site utilizada no exemplo:

Existe apenas uma tabela com o nome VirtualFileSystem na base de dados. Esta tabela tem o seguinte aspecto:

A hierarquia do Web site no Visual Studio tem o seguinte aspecto:


notas

• A pasta App_Code contém todas as classes necessárias para implementar um fornecedor de caminho virtual, tal como a classe VirtualPathProvider , a classe VirtualDirectory , a classe VirtualFile e uma classe de utilitário .
• A pasta SharePointDir representa um directório virtual. O conteúdo deste directório virtual é armazenado na base de dados. Qualquer pedido para uma página dentro desta pasta será considerado como um pedido para um ficheiro virtual pelo runtime ASP.NET.
• A página AdminstrationPage.aspx apresenta uma interface de utilizador onde é possível executar CRUD operações (criar, ler, actualizar e eliminar) no conteúdo virtual com a ajuda de um controlo de GridView . A página AdminstrationPage.aspx tem o seguinte aspecto:

Informe-nos inicie criar o exemplo.

Para o fazer, siga estes passos:

1. Inicie o Visual Studio 2005.
2. Crie um Web site que tem o hierarquia exacta e ficheiros que parecem na imagem anterior.
3. Abra o ficheiro de origem SharePointDirectory.cs.
4. Verifique se espaços de nomes seguintes estão incluídos no ficheiro 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 dois 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 neste processo. O ASP.NET motor runtime chama este método quando a aplicação está a ser iniciado.
   
   Nota Este método pode ser considerado como uma vaza em que fazemos runtime ASP.NET carregar esta classe sem qualquer ficheiro Web.config.
   
   Se temos mais do que uma classe em conjunto com este método, ocorre um erro de compilação. Dentro deste método, são registar nosso fornecedor com o ambiente de hospedagem do ASP.NET. Agora, todos os pedidos para uma página Web passará a este fornecedor.

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

8. Implemente o construtor para a classe SharePointProvider . Este passo é onde é apresentará todos os ficheiros virtuais e respectivo conteúdo na memória para um acesso mais rápido. Até o conteúdo é invalidado, utilizaremos o conjunto de resultados na memória. Assim que o conteúdo for alterado na base de dados, o conteúdo necessita de ser actualizado.

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

9. Em seguida, adicione o método IsPathVirtual . Utilizando este método, pode determinar se o ficheiro pedido é de um caminho virtual. Já decidimos esse ficheiro pedido na pasta SharePointDir será considerado como um ficheiro virtual.

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

10. O método FileExists devolve se o ficheiro existe. Isto acontece por verificar que o ficheiro pedido existe na base de dados. Se o ficheiro não existir, é obterá a referência do objecto de fornecedor de caminho virtual previamente registado no sistema de compilação e é tentará localizar o ficheiro novamente chamando o método FileExists . Se o ficheiro ainda não for encontrado, irá receber outro "404 (ficheiro 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. Do mesmo modo têm o método DirectoryExists . Este método devolve VERDADEIRO se o fornecedor pode servir o caminho do ficheiro virtual que é transmitido como um argumento. Caso contrário, o fornecedor apresentará o caminho de ficheiro virtual do fornecedor previamente registado como habitualmente e 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 . Tempo de execução ASP.NET chama estes métodos no fornecedor de caminho virtual depois das chamadas para os métodos de DirectoryExists e FileExists com êxito.

    //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. Deve adicionar alguns métodos de utilitário que serão utilizados 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; }
    }

    NOTA: neste exemplo, estamos a não utilizar o mecanismo para notificar o sistema de compilação de quaisquer alterações efectuadas a conteúdo virtual. O fornecedor virtual expõe uma API que chama GetCacheDependency utilizada para ajudar a cache recursos virtuais. Pode invalidar a cache quando qualquer um dos ficheiros tornam-se inválido. Para mais informações, visite o seguinte site da Web 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. Foi terminados com a classe de fornecedor principal. Agora abra o ficheiro de origem SharePointDirectory.cs. Esta classe servirá como uma abstracção para recursos virtualizados. Para obter mais informações sobre a classe VirtualDirectory , visite o seguinte site da Web 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. Uma vez que a classe VirtualDirectory é uma classe abstracta, é necessário substituir todos os métodos abstractos. No entanto, não facultaremos a implementação adicional sobre os métodos substituídos porque neste exemplo é assumir que é enviado conteúdo virtual num único directório virtual. Por este motivo, a definição de classe vai assemelhar-se 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, está prontos para definir uma classe mais chama SharePointVirtualFile que expande a classe abstracta VirtualFile . Esta classe tem um método abstracto substituído denominado OpenFile . O método OpenFile devolve uma instância de sequência que é utilizada pelo ASP.NET criar ambiente para consumir o ficheiro 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. Pelo último, irá definir a classe DBUtiliity no ficheiro DBUtility.cs . A implementação de método não for fornecida. A classe DBUtiliity é utilizada por classes de fornecedor para obter o conteúdo da base de dados em conjunto 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.	
        }
    }
    

    Nota um aspecto a ter em consideração é que registar um fornecedor é uma operação privilegiada porque pode alterar o conteúdo apresentado. Classes personalizadas para as classes VirtualPathProvider VirtualDirectory e VirtualFile tem de executar em permissões de fidedignidade total . Para mais informações, visite a MSDN seguinte Web site:
    http://msdn2.microsoft.com/en-us/library/system.web.aspnethostingpermission.aspx (http://msdn2.microsoft.com/en-us/library/system.web.aspnethostingpermission.aspx)
18. Foi terminados escrever as classes de fornecedor e agora a aplicação está pronto para servir conteúdo virtual. Para atribuir a aplicação o aspecto e comportamento de uma página Web de administração de SharePoint Portal Services, criou uma página AdministrationPage.aspx na pasta raiz do Web 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 fornecedores de caminho virtual, este é tudo por agora. Espero que esta coluna irá ajudar a compreender o processo de compilação básicas para ASP.NET 2.0 e como a Microsoft pode permitir que o runtime do ASP.NET trabalhar com conteúdo com base não ficheiro, tais como conteúdo servidos a partir de uma base de dados.

Obrigado pelo seu tempo. Esperamos que escrever mais informações sobre as novas funcionalidades adicionadas no ASP.NET 2.0. Para mais informações e exemplos, visite os sites da Web MSDN:

Como sempre, vontade submeter ideias tópicos que pretende no futuro corrigida colunas ou na base de dados de conhecimento utilizando o formulário Ask For It (http://support.microsoft.com/common/survey.aspx?scid=sw;en;1176&p0=&p1=&p2=&p3=&p4=) .