Armazenar dados em cache na arquitetura (C#)

por Scott Mitchell

Baixar PDF

No tutorial anterior, aprendemos a aplicar o cache na Camada de Apresentação. Neste tutorial, aprendemos a aproveitar nossa arquitetura em camadas para armazenar dados em cache na Camada lógica de negócios. Fazemos isso estendendo a arquitetura para incluir uma camada de cache.

Introdução

Como vimos no tutorial anterior, armazenar em cache os dados de ObjectDataSource é tão simples quanto definir algumas propriedades. Infelizmente, o ObjectDataSource aplica o cache na Camada de Apresentação, que associa firmemente as políticas de cache com a página ASP.NET. Um dos motivos para criar uma arquitetura em camadas é permitir que esses acoplamentos sejam quebrados. A Camada de Lógica de Negócios, por exemplo, separa a lógica de negócios das páginas de ASP.NET, enquanto a Camada de Acesso a Dados separa os detalhes de acesso a dados. Essa desacoplamento da lógica de negócios e dos detalhes de acesso a dados é preferencial, em parte, porque torna o sistema mais legível, mais mantenedível e mais flexível para alterar. Ele também permite o conhecimento de domínio e a divisão de trabalho que um desenvolvedor que trabalha na Camada de Apresentação não precisa estar familiarizado com os detalhes do banco de dados para fazer seu trabalho. A desacoplamento da política de cache da Camada de Apresentação oferece benefícios semelhantes.

Neste tutorial, aumentaremos nossa arquitetura para incluir uma camada de cache (ou CL para abreviar) que emprega nossa política de cache. A Camada de Cache incluirá uma ProductsCL classe que fornece acesso às informações do produto com métodos como GetProducts(), GetProductsByCategoryID(categoryID)e assim por diante, que, quando invocado, tentará primeiro recuperar os dados do cache. Se o cache estiver vazio, esses métodos invocarão o método apropriado ProductsBLL na BLL, que, por sua vez, obteria os dados do DAL. Os ProductsCL métodos armazenam em cache os dados recuperados da BLL antes de retorná-los.

Como mostra a Figura 1, a CL reside entre as Camadas lógicas de apresentação e de negócios.

Figura 1: A CL (camada de cache) é outra camada em nossa arquitetura

Etapa 1: Criando as classes de camada de cache

Neste tutorial, criaremos uma CL muito simples com uma única classe ProductsCL que tem apenas alguns métodos. A criação de uma camada de cache completa para todo o aplicativo exigiria a criação CategoriesCLde classes , EmployeesCLe SuppliersCL e o fornecimento de um método nessas classes de camada de cache para cada método de acesso a dados ou modificação na BLL. Assim como acontece com a BLL e a DAL, a Camada de Cache deve ser implementada idealmente como um projeto separado da Biblioteca de Classes; no entanto, vamos implementá-lo como uma classe na App_Code pasta .

Para separar mais claramente as classes CL das classes DAL e BLL, vamos criar uma nova subpasta na App_Code pasta . Clique com o botão direito do App_Code mouse na pasta no Gerenciador de Soluções, escolha Nova Pasta e nomeie a nova pasta CLcomo . Depois de criar essa pasta, adicione a ela uma nova classe chamada ProductsCL.cs.

Figura 2: Adicionar uma nova pasta chamada CL e uma classe chamada ProductsCL.cs

A ProductsCL classe deve incluir o mesmo conjunto de métodos de acesso e modificação de dados, conforme encontrado em sua classe de camada de lógica de negócios correspondente (ProductsBLL). Em vez de criar todos esses métodos, vamos criar um par aqui para ter uma ideia dos padrões usados pelo CL. Em particular, adicionaremos os GetProducts() métodos e GetProductsByCategoryID(categoryID) na Etapa 3 e uma UpdateProduct sobrecarga na Etapa 4. Você pode adicionar os métodos restantes ProductsCL e CategoriesCLas classes , EmployeesCLe SuppliersCL no seu lazer.

Etapa 2: Leitura e gravação no cache de dados

O recurso de cache ObjectDataSource explorado no tutorial anterior usa internamente o cache de dados ASP.NET para armazenar os dados recuperados da BLL. O cache de dados também pode ser acessado programaticamente de ASP.NET classes code-behind de páginas ou das classes na arquitetura do aplicativo Web. Para ler e gravar no cache de dados de uma classe code-behind da página ASP.NET, use o seguinte padrão:

// Read from the cache
object value = Cache["key"];
// Add a new item to the cache
Cache["key"] = value;
Cache.Insert(key, value);
Cache.Insert(key, value, CacheDependency);
Cache.Insert(key, value, CacheDependency, DateTime, TimeSpan);

O Cache método da classe s Insert tem várias sobrecargas. Cache["key"] = value e Cache.Insert(key, value) são sinônimos e adicionam um item ao cache usando a chave especificada sem uma expiração definida. Normalmente, queremos especificar uma expiração ao adicionar um item ao cache, seja como uma dependência, uma expiração baseada em tempo ou ambas. Use uma das sobrecargas de outro Insert método para fornecer informações de expiração baseadas em dependência ou tempo.

Os métodos da Camada de Cache precisam primeiro marcar se os dados solicitados estiverem no cache e, nesse caso, retorná-los de lá. Se os dados solicitados não estiverem no cache, o método BLL apropriado precisará ser invocado. Seu valor retornado deve ser armazenado em cache e retornado, como ilustra o diagrama de sequência a seguir.

Figura 3: Os métodos da camada de cache retornam dados do cache se estiverem disponíveis

A sequência ilustrada na Figura 3 é realizada nas classes CL usando o seguinte padrão:

Type instance = Cache["key"] as Type;
if (instance == null)
{
    instance = BllMethodToGetInstance();
    Cache.Insert(key, instance, ...);
}
return instance;

Aqui, Tipo é o tipo de dados que está sendo armazenado no cache Northwind.ProductsDataTable, por exemplo, enquanto key é a chave que identifica exclusivamente o item de cache. Se o item com a chave especificada não estiver no cache, a instância será null e os dados serão recuperados do método BLL apropriado e adicionados ao cache. Quando é atingido, a return instanceinstância contém uma referência aos dados, seja do cache ou extraída da BLL.

Certifique-se de usar o padrão acima ao acessar dados do cache. O padrão a seguir, que, à primeira vista, parece equivalente, contém uma diferença sutil que introduz uma condição de corrida. As condições de corrida são difíceis de depurar porque se revelam esporadicamente e são difíceis de reproduzir.

if (Cache["key"] == null)
{
    Cache.Insert(key, BllMethodToGetInstance(), ...);
}
return Cache["key"];

A diferença neste segundo snippet de código incorreto é que, em vez de armazenar uma referência ao item armazenado em cache em uma variável local, o cache de dados é acessado diretamente na instrução condicional e no return. Imagine que, quando esse código é atingido, Cache["key"] nãonull é, mas antes que a return instrução seja atingida, o sistema remove a chave do cache. Nesse caso raro, o código retornará um null valor em vez de um objeto do tipo esperado.

Observação

O cache de dados é thread-safe, portanto, você não precisa sincronizar o acesso de thread para leituras ou gravações simples. No entanto, se você precisar executar várias operações em dados no cache que precisam ser atômicos, será responsável por implementar um bloqueio ou algum outro mecanismo para garantir a segurança do thread. Consulte Synchronizing Access to the ASP.NET Cache para obter mais informações.

Um item pode ser removido programaticamente do cache de dados usando o Remove método da seguinte forma:

Cache.Remove(key);

Etapa 3: Retornando informações do produto daProductsCLclasse

Para este tutorial, vamos implementar dois métodos para retornar informações do produto da ProductsCL classe : GetProducts() e GetProductsByCategoryID(categoryID). Assim como acontece com a ProductsBL classe na Camada de Lógica de Negócios, o GetProducts() método na CL retorna informações sobre todos os produtos como um Northwind.ProductsDataTable objeto, enquanto GetProductsByCategoryID(categoryID) retorna todos os produtos de uma categoria especificada.

O código a seguir mostra uma parte dos métodos na ProductsCL classe :

[System.ComponentModel.DataObject]
public class ProductsCL
{
    private ProductsBLL _productsAPI = null;
    protected ProductsBLL API
    {
        get
        {
            if (_productsAPI == null)
                _productsAPI = new ProductsBLL();
            return _productsAPI;
        }
    }
    
   [System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Select, true)]
    public Northwind.ProductsDataTable GetProducts()
    {
        const string rawKey = "Products";
        // See if the item is in the cache
        Northwind.ProductsDataTable products = _
            GetCacheItem(rawKey) as Northwind.ProductsDataTable;
        if (products == null)
        {
            // Item not found in cache - retrieve it and insert it into the cache
            products = API.GetProducts();
            AddCacheItem(rawKey, products);
        }
        return products;
    }
    
    [System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Select, false)]
    public Northwind.ProductsDataTable GetProductsByCategoryID(int categoryID)
    {
        if (categoryID < 0)
            return GetProducts();
        else
        {
            string rawKey = string.Concat("ProductsByCategory-", categoryID);
            // See if the item is in the cache
            Northwind.ProductsDataTable products = _
                GetCacheItem(rawKey) as Northwind.ProductsDataTable;
            if (products == null)
            {
                // Item not found in cache - retrieve it and insert it into the cache
                products = API.GetProductsByCategoryID(categoryID);
                AddCacheItem(rawKey, products);
            }
            return products;
        }
    }
}

Primeiro, observe os DataObject atributos e DataObjectMethodAttribute aplicados à classe e aos métodos. Esses atributos fornecem informações para o assistente objectDataSource s, indicando quais classes e métodos devem aparecer nas etapas do assistente. Como as classes e os métodos CL serão acessados de um ObjectDataSource na Camada de Apresentação, adicionei esses atributos para aprimorar a experiência de tempo de design. Consulte o tutorial Criando uma camada de lógica de negócios para obter uma descrição mais completa sobre esses atributos e seus efeitos.

GetProducts() Nos métodos e GetProductsByCategoryID(categoryID) , os dados retornados do GetCacheItem(key) método são atribuídos a uma variável local. O GetCacheItem(key) método , que examinaremos em breve, retorna um item específico do cache com base na chave especificada. Se esses dados não forem encontrados no cache, eles serão recuperados do método de classe correspondente ProductsBLL e, em seguida, adicionados ao cache usando o AddCacheItem(key, value) método .

A interface de GetCacheItem(key) métodos e AddCacheItem(key, value) com o cache de dados, lendo e gravando valores, respectivamente. O GetCacheItem(key) método é o mais simples dos dois. Ele simplesmente retorna o valor da classe Cache usando a chave passada:

private object GetCacheItem(string rawKey)
{
    return HttpRuntime.Cache[GetCacheKey(rawKey)];
}
private readonly string[] MasterCacheKeyArray = {"ProductsCache"};
private string GetCacheKey(string cacheKey)
{
    return string.Concat(MasterCacheKeyArray[0], "-", cacheKey);
}

GetCacheItem(key) não usa o valor da chave conforme fornecido, mas chama o GetCacheKey(key) método , que retorna a chave acrescentada com ProductsCache-. O MasterCacheKeyArray, que contém a cadeia de caracteres ProductsCache, também é usado pelo AddCacheItem(key, value) método , como veremos momentaneamente.

Em uma classe code-behind de página ASP.NET, o cache de dados pode ser acessado usando a Page propriedade da classe e Cachepermite a sintaxe como Cache["key"] = value, conforme discutido na Etapa 2. De uma classe dentro da arquitetura, o cache de dados pode ser acessado usando ou HttpRuntime.CacheHttpContext.Current.Cache. A entrada de blog de Peter JohnsonHttpRuntime.Cache vs. HttpContext.Current.Cache observa a pequena vantagem de desempenho em usar HttpRuntime em vez de HttpContext.Current; consequentemente, ProductsCL usa HttpRuntime.

Observação

Se sua arquitetura for implementada usando projetos da Biblioteca de Classes, você precisará adicionar uma referência ao System.Web assembly para usar as classes HttpRuntime e HttpContext .

Se o item não for encontrado no cache, os ProductsCL métodos da classe s obterão os dados da BLL e os adicionarão ao cache usando o AddCacheItem(key, value) método . Para adicionar valor ao cache, poderíamos usar o seguinte código, que usa uma expiração de 60 segundos:

const double CacheDuration = 60.0;
private void AddCacheItem(string rawKey, object value)
{
    HttpRuntime.Cache.Insert(GetCacheKey(rawKey), value, null, 
        DateTime.Now.AddSeconds(CacheDuration), Caching.Cache.NoSlidingExpiration);
}

DateTime.Now.AddSeconds(CacheDuration) especifica a expiração baseada em tempo de 60 segundos no futuro, enquanto System.Web.Caching.Cache.NoSlidingExpiration indica que não há expiração deslizante. Embora essa Insert sobrecarga de método tenha parâmetros de entrada para uma expiração absoluta e deslizante, você só pode fornecer um dos dois. Se você tentar especificar um tempo absoluto e um intervalo de tempo, o Insert método gerará uma exceção ArgumentException .

Observação

Essa implementação do AddCacheItem(key, value) método atualmente tem algumas deficiências. Abordaremos e superaremos esses problemas na Etapa 4.

Etapa 4: Invalidando o cache quando os dados são modificados por meio da arquitetura

Juntamente com os métodos de recuperação de dados, a Camada de Cache precisa fornecer os mesmos métodos que a BLL para inserir, atualizar e excluir dados. Os métodos de modificação de dados da CL não modificam os dados armazenados em cache, mas chamam o método de modificação de dados correspondente da BLL e invalidam o cache. Como vimos no tutorial anterior, esse é o mesmo comportamento que o ObjectDataSource aplica quando seus recursos de cache são habilitados e seus Insertmétodos , Updateou Delete são invocados.

UpdateProduct A seguinte sobrecarga ilustra como implementar os métodos de modificação de dados na CL:

[System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Update, false)]
public bool UpdateProduct(string productName, decimal? unitPrice, int productID)
{
    bool result = API.UpdateProduct(productName, unitPrice, productID);
    // TODO: Invalidate the cache
    return result;
}

O método de camada de lógica de negócios de modificação de dados apropriado é invocado, mas antes que sua resposta seja retornada, precisamos invalidar o cache. Infelizmente, invalidar o cache não é simples porque as classes e GetProducts()GetProductsByCategoryID(categoryID) os ProductsCL métodos adicionam itens ao cache com chaves diferentes e o GetProductsByCategoryID(categoryID) método adiciona um item de cache diferente para cada categoryID exclusivo.

Ao invalidar o cache, precisamos remover todos os itens que podem ter sido adicionados pela ProductsCL classe . Isso pode ser feito associando uma dependência de cache com cada item adicionado ao cache no AddCacheItem(key, value) método . Em geral, uma dependência de cache pode ser outro item no cache, um arquivo no sistema de arquivos ou dados de um banco de dados do Microsoft SQL Server. Quando a dependência é alterada ou removida do cache, os itens de cache aos quais ele está associado são removidos automaticamente do cache. Para este tutorial, queremos criar um item adicional no cache que serve como uma dependência de cache para todos os itens adicionados por meio da ProductsCL classe . Dessa forma, todos esses itens podem ser removidos do cache simplesmente removendo a dependência de cache.

Vamos atualizar o AddCacheItem(key, value) método para que cada item adicionado ao cache por meio desse método esteja associado a uma única dependência de cache:

private void AddCacheItem(string rawKey, object value)
{
    System.Web.Caching.Cache DataCache = HttpRuntime.Cache;
    // Make sure MasterCacheKeyArray[0] is in the cache - if not, add it
    if (DataCache[MasterCacheKeyArray[0]] == null)
        DataCache[MasterCacheKeyArray[0]] = DateTime.Now;
    // Add a CacheDependency
    System.Web.Caching.CacheDependency dependency = 
        new CacheDependency(null, MasterCacheKeyArray);
    DataCache.Insert(GetCacheKey(rawKey), value, dependency, 
        DateTime.Now.AddSeconds(CacheDuration), 
        System.Web.Caching.Cache.NoSlidingExpiration);
}

MasterCacheKeyArray é uma matriz de cadeia de caracteres que contém um único valor, ProductsCache. Primeiro, um item de cache é adicionado ao cache e atribuído a data e hora atuais. Se o item de cache já existir, ele será atualizado. Em seguida, uma dependência de cache é criada. O CacheDependency construtor da classe tem várias sobrecargas, mas o que está sendo usado aqui espera duas string entradas de matriz. O primeiro especifica o conjunto de arquivos a serem usados como dependências. Como não queremos usar dependências baseadas em arquivo, um valor de null é usado para o primeiro parâmetro de entrada. O segundo parâmetro de entrada especifica o conjunto de chaves de cache a serem usadas como dependências. Aqui, especificamos nossa dependência única, MasterCacheKeyArray. Em CacheDependency seguida, o é passado para o Insert método .

Com essa modificação em AddCacheItem(key, value), invalidar o cache é tão simples quanto remover a dependência.

[System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Update, false)]
public bool UpdateProduct(string productName, decimal? unitPrice, int productID)
{
    bool result = API.UpdateProduct(productName, unitPrice, productID);
    // Invalidate the cache
    InvalidateCache();
    return result;
}
public void InvalidateCache()
{
    // Remove the cache dependency
    HttpRuntime.Cache.Remove(MasterCacheKeyArray[0]);
}

Etapa 5: Chamando a camada de cache da camada de apresentação

As classes e métodos da Camada de Cache podem ser usados para trabalhar com dados usando as técnicas que examinamos ao longo desses tutoriais. Para ilustrar o trabalho com dados armazenados em cache, salve suas alterações na ProductsCL classe e abra a FromTheArchitecture.aspx página na Caching pasta e adicione um GridView. Na marca inteligente gridView, crie um novo ObjectDataSource. Na primeira etapa do assistente, você deve ver a ProductsCL classe como uma das opções da lista suspensa.

Figura 4: a ProductsCL classe está incluída na Lista de Drop-Down de Objetos Corporativos (clique para exibir a imagem em tamanho real)

Depois de ProductsCLselecionar , clique em Avançar. A lista suspensa na guia SELECT tem dois itens e GetProducts()GetProductsByCategoryID(categoryID) a guia UPDATE tem a única UpdateProduct sobrecarga. Escolha o GetProducts() método na guia SELECT e o UpdateProducts método na guia UPDATE e clique em Concluir.

Figura 5: Os ProductsCL métodos de classe são listados no Drop-Down Listas (Clique para exibir a imagem em tamanho real)

Depois de concluir o assistente, o Visual Studio definirá a propriedade original_{0} ObjectDataSource como OldValuesParameterFormatString e adicionará os campos apropriados ao GridView. Altere a OldValuesParameterFormatString propriedade de volta para seu valor padrão, {0}e configure o GridView para dar suporte à paginação, classificação e edição. Como a UploadProducts sobrecarga usada pelo CL aceita apenas o nome e o preço do produto editado, limite o GridView para que apenas esses campos sejam editáveis.

No tutorial anterior, definimos um GridView para incluir campos para os ProductNamecampos , CategoryNamee UnitPrice . Fique à vontade para replicar essa formatação e estrutura, nesse caso, a marcação declarativa de GridView e ObjectDataSource deve ser semelhante à seguinte:

<asp:GridView ID="Products" runat="server" AutoGenerateColumns="False" 
    DataKeyNames="ProductID" DataSourceID="ProductsDataSource" 
    AllowPaging="True" AllowSorting="True">
    <Columns>
        <asp:CommandField ShowEditButton="True" />
        <asp:TemplateField HeaderText="Product" SortExpression="ProductName">
            <EditItemTemplate>
                <asp:TextBox ID="ProductName" runat="server" 
                    Text='<%# Bind("ProductName") %>' />
                <asp:RequiredFieldValidator ID="RequiredFieldValidator1"
                    ControlToValidate="ProductName" Display="Dynamic" 
                    ErrorMessage="You must provide a name for the product." 
                    SetFocusOnError="True"
                    runat="server">*</asp:RequiredFieldValidator>
            </EditItemTemplate>
            <ItemTemplate>
                <asp:Label ID="Label2" runat="server" 
                    Text='<%# Bind("ProductName") %>'></asp:Label>
            </ItemTemplate>
        </asp:TemplateField>
        <asp:BoundField DataField="CategoryName" HeaderText="Category" 
            ReadOnly="True" SortExpression="CategoryName" />
        <asp:TemplateField HeaderText="Price" SortExpression="UnitPrice">
            <EditItemTemplate>
                $<asp:TextBox ID="UnitPrice" runat="server" Columns="8" 
                    Text='<%# Bind("UnitPrice", "{0:N2}") %>'></asp:TextBox>
                <asp:CompareValidator ID="CompareValidator1" runat="server" 
                    ControlToValidate="UnitPrice" Display="Dynamic" 
                    ErrorMessage="You must enter a valid currency value with 
                        no currency symbols. Also, the value must be greater than 
                        or equal to zero."
                    Operator="GreaterThanEqual" SetFocusOnError="True" 
                    Type="Currency" ValueToCompare="0">*</asp:CompareValidator>
            </EditItemTemplate>
            <ItemStyle HorizontalAlign="Right" />
            <ItemTemplate>
                <asp:Label ID="Label1" runat="server" 
                    Text='<%# Bind("UnitPrice", "{0:c}") %>' />
            </ItemTemplate>
        </asp:TemplateField>
    </Columns>
</asp:GridView>
<asp:ObjectDataSource ID="ProductsDataSource" runat="server" 
    OldValuesParameterFormatString="{0}" SelectMethod="GetProducts" 
    TypeName="ProductsCL" UpdateMethod="UpdateProduct">
    <UpdateParameters>
        <asp:Parameter Name="productName" Type="String" />
        <asp:Parameter Name="unitPrice" Type="Decimal" />
        <asp:Parameter Name="productID" Type="Int32" />
    </UpdateParameters>
</asp:ObjectDataSource>

Neste ponto, temos uma página que usa a Camada de Cache. Para ver o cache em ação, defina pontos de interrupção nas ProductsCL classes e GetProducts()UpdateProduct métodos. Visite a página em um navegador e percorra o código ao classificar e paginar para ver os dados extraídos do cache. Em seguida, atualize um registro e observe que o cache é invalidado e, consequentemente, ele é recuperado da BLL quando os dados são recuperados para o GridView.

Observação

A Camada de Cache fornecida no download que acompanha este artigo não está concluída. Ele contém apenas uma classe, ProductsCL, que apenas ostenta um punhado de métodos. Além disso, apenas uma única página ASP.NET usa a CL (~/Caching/FromTheArchitecture.aspx) todas as outras ainda referenciam a BLL diretamente. Se você planeja usar uma CL em seu aplicativo, todas as chamadas da Camada de Apresentação devem ir para o CL, o que exigiria que as classes e métodos de CL abordassem essas classes e métodos na BLL atualmente usada pela Camada de Apresentação.

Resumo

Embora o cache possa ser aplicado na Camada de Apresentação com os controles SqlDataSource e ObjectDataSource do ASP.NET 2.0, o ideal é que as responsabilidades de cache sejam delegadas a uma camada separada na arquitetura. Neste tutorial, criamos uma Camada de Cache que reside entre a Camada de Apresentação e a Camada lógica de negócios. A Camada de Cache precisa fornecer o mesmo conjunto de classes e métodos que existem na BLL e são chamados da Camada de Apresentação.

Os exemplos da Camada de Cache que exploramos neste e nos tutoriais anteriores exibiram o carregamento reativo. Com o carregamento reativo, os dados são carregados no cache somente quando uma solicitação para os dados é feita e esses dados estão ausentes do cache. Os dados também podem ser carregados proativamente no cache, uma técnica que carrega os dados no cache antes que eles sejam realmente necessários. No próximo tutorial, veremos um exemplo de carregamento proativo quando examinarmos como armazenar valores estáticos no cache na inicialização do aplicativo.

Programação feliz!

Sobre o autor

Scott Mitchell, autor de sete livros do ASP/ASP.NET e fundador da 4GuysFromRolla.com, trabalha com tecnologias da Microsoft Web desde 1998. Scott trabalha como consultor independente, treinador e escritor. Seu último livro é Sams Teach Yourself ASP.NET 2.0 em 24 Horas. Ele pode ser contatado em mitchell@4GuysFromRolla.com. ou através de seu blog, que pode ser encontrado em http://ScottOnWriting.NET.

Agradecimentos Especiais

Esta série de tutoriais foi revisada por muitos revisores úteis. A revisora principal deste tutorial foi Teresa Murph. Interessado em revisar meus próximos artigos do MSDN? Nesse caso, solte-me uma linha em mitchell@4GuysFromRolla.com.

AnteriorAvançar