http://www.MenuDaInternet.com/DOTNET
http://www.MenuDaInternet.com/blogDOTNET
Tudo sobre .NET


 

Pesquisar:     

Postagem do dono do blog: (08/12/2014 23:16:27)

Rastreamento de AJAX. Inserir seu conteúdo AJAX nos mecanismos de busca.


Visão geral

Se estiver executando um aplicativo AJAX com conteúdo que gostaria que aparecesse nos resultados de pesquisa, temos um novo processo que, quando implementado, pode ajudar o Google (e, potencialmente, outros mecanismos de pesquisa) a rastrearem e indexarem o seu conteúdo. Historicamente, os aplicativos AJAX têm sido difíceis para os mecanismos de pesquisa processarem porque o conteúdo AJAX é produzido dinamicamente pelo navegador e, desse modo, não fica visível aos rastreadores. Embora haja métodos para lidar com esse problema, eles envolvem manutenção manual regular para manter o conteúdo atualizado.

Em comparação, o esquema abaixo ajuda os mecanismos de pesquisa a rastrearem e indexarem o seu conteúdo de modo escalável e ajuda os webmasters a manterem o conteúdo indexado atualizado sem esforço manual contínuo. Se o seu aplicativo AJAX adotar este esquema, seu conteúdo aparecer em resultados de pesquisa. O esquema funciona do seguinte modo:

O site adota o esquema de rastreamento do AJAX.
O seu servidor fornece um instantâneo HTML para cada URL em AJAX, que é o conteúdo que um usuário (com um navegador) vê. Um URL em AJAX é um URL que contém um fragmento hash, por exemplo, www.example.com/index.html#mystate, no qual #mystate é o fragmento hash. Um instantâneo HTML é todo o conteúdo que aparece na página após o JavaScript ter sido executado.
O mecanismo de pesquisa indexa o instantâneo HTML e exibe os seus URLs em AJAX nos seus resultados de pesquisa.
Para fazer isso funcionar, o aplicativo deve usar uma sintaxe específica nos URLs em AJAX (vamos chamá-los de "URLs belos". Você saberá o motivo nas seções seguintes). O rastreador do mecanismo de pesquisa modificará, temporariamente, esses "URLs belos" para "URLs feios" e os solicitará do seu servidor. Essa solicitação por um "URL feio" indica para o servidor que ele não deve retornar uma página web regular que forneceria a um navegador, mas sim um instantâneo HTML. Quando o rastreador tiver obtido o conteúdo para o URL feio modificado, indexa o seu conteúdo, depois exibe o URL belo original nos resultados de busca. Em outras palavras, os usuários finais sempre verão o URL belo que contém um fragmento hash.

Guia passo a passo

1. Indicar ao rastreador que o seu site oferece suporte para o esquema de rastreamento de AJAX.
O primeiro passo para ter seu site em AJAX indexado é indicar ao rastreador que o seu site oferece suporte para o esquema de rastreamento de AJAX. Para isso, é preciso usar um token especial nos seus fragmentos hash (isto é, tudo após o # registrado em um URL). Os fragmentos hash que representam estados de página únicos devem começar com um ponto de exclamação. Por exemplo, se o seu aplicativo AJAX contiver um URL como este:


www.example.com/ajax.html#mystate
deve ficar assim:

www.example.com/ajax.html#!mystate
Quando o seu site adotar o esquema, será considerado "AJAX rastreável". Isso significa que o rastreador verá o conteúdo do seu aplicativo se o seu site oferecer instantâneos HTML.

2. Ajustar o seu servidor para manipular solicitações de URLs que contenham "_escaped_fragment_"
Suponha que você gostaria que www.example.com/index.html#!mystate fosse indexado. Sua parte do acordo é fornecer ao rastreador um instantâneo HTML desse URL para que ele veja o conteúdo. Como o seu servidor saberá quando retornar um instantâneo HTML em vez da página regular? A resposta está no URL solicitado pelo rastreador: o rastreador modificará cada URL em AJAX, como www.example.com/ajax.html#!mystate, para ser, temporariamente, www.example.com/ajax.html?_escaped_fragment_=mystate. Referimo-nos ao formador como um "URL belo" e, ao último, como "URL feio".

Isso é importante mais dois motivos:

Os fragmentos hash nunca são (por especificação) enviados ao servidor como parte de uma solicitação HTTP. Em outras palavras, o rastreador precisa, de algum modo, deixar o seu servidor saber que quer o conteúdo para o URL www.example.com/ajax.html#!mystate.
O seu servidor, por outro lado, precisa saber que retornou um instantâneo HTML, não a página normal enviada ao navegador. Lembre-se: Um instantâneo HTML é todo o conteúdo que aparece na página após o JavaScript ter sido executado. O fim do acordo do seu servidor é retornar o instantâneo HTML de www.example.com/index.html#!mystate (isto é, o URL original) para o rastreador.
Observação: O rastreador deixa escapar alguns caracteres no fragmento durante a transformação. Para recuperar o fragmento original, certifique-se de resgatar todos os caracteres %XXX no fragmento (por exemplo, %26 deve se tornar '&smp;', %20 deve se tornar um espaço, %23 deve se tornar # e %25 deve se tornar %).

Agora que você tem o seu URL original de volta e sabe qual conteúdo o rastreador está solicitando, precisa produzir um instantâneo HTML. Alguns modos de fazer isso são os seguintes:

Se muito do seu conteúdo for produzido com JavaScript, é recomendável usar um navegador sem cabeçalho, como o HtmlUnit, para obter um instantâneo HTML. Como alternativa, use uma ferramenta diferente, como crawljax ou watij.com.
Se muito do seu conteúdo for produzido com uma tecnologia de servidor, como PHP ou ASP.NET, use o seu código existente e substitua somente as partes em JavaScript da sua página web com HTML estático ou criado por servidor.
Você pode criar uma versão estática das suas páginas off-line. Por exemplo, muitos aplicativos tiram conteúdo de um banco de dados, que depois é renderizado pelo navegador. Em vez disso, você pode criar uma página HTML separada para cada URL em AJAX. É parecido com a recomendação Hijax anterior do Google.
3. Manipular páginas sem fragmentos hash
Algumas das suas páginas podem não ter fragmentos hash. Por exemplo, você provavelmente prefere que a sua página inicial seja www.example.com em vez de www.example.com#!home. Por esse motivo, temos uma condição especial para páginas sem fragmentos hash.

Para que as páginas sem fragmentos hash sejam indexadas, inclua uma meta tag especial no cabeçalho do HTML da sua página. Importante: certifique-se de usar esta solução apenas para páginas que incluem conteúdo de Ajax. Adicioná-la a páginas que não são de Ajax não gera nenhum benefício e sobrecarrega seus servidores e os do Google. A metatag tem o seguinte formulário:

<meta name="fragment" content="!">
Essa tag indica ao rastreador que ele deve rastrear a versão feia desse URL. Como no acordo acima, o rastreador mapeará, temporariamente, o URL belo para o URL feio correspondente. Em outras palavras, se você colocar <meta name="fragment" content="!"> na página www.example.com, o rastreador mapeará, temporariamente, esse URL para www.example.com?_escaped_fragment_= e o solicitará do seu servidor . Seu servidor deve, então, retornar o instantâneo HTML correspondente ao www.example.com.

Uma restrição importante se aplica a essa meta tag: o único conteúdo válido é "!". Em outras palavras, a meta tag sempre ficará na forma exata: <meta name="fragment" content="!">, que indica um fragmento hash vazio, mas uma página com conteúdo AJAX.

4. Considerar a atualização do seu Sitemap para listar os novos URLs em AJAX
Os rastreadores usam Sitemaps para complementar o rastreamento de descoberta. O seu Sitemap deve incluir a versão dos seus URLs que você gostaria que fosse exibida em resultados de pesquisa. Na maioria dos casos, seria http://example.com/ajax.html#!foo=123 (em vez de http://example.com/ajax.html?_escaped_fragment_=foo=123), a menos que você tenha uma página de entrada para o seu site, como a sua página inicial, que gostaria de exibir em resultados de pesquisa sem o #!. Por exemplo, se quiser que os resultados de pesquisa exibam http://example.com/, inclua http://example.com/ no seu Sitemap com <meta name="fragment" content="!"> no <cabeçalho> do seu documento. Para obter mais informações, veja os nossos artigos adicionais sobre Sitemaps.


Postagem do dono do blog: (13/08/2014 22:52:09)
Usando Dictionary em c#


Se você precisa guarda valores em uma matriz e depois buscar eles por um nome/identificador ao invés de colocar o índice, use dictionary.

Segue exemplo: 




using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Create a new dictionary of strings, with string keys.
        //
        Dictionary<string, string> openWith = 
            new Dictionary<string, string>();

        // Add some elements to the dictionary. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is 
        // already in the dictionary.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("An element with Key = "txt" already exists.");
        }

        // The Item property is another name for the indexer, so you 
        // can omit its name when accessing elements. 
        Console.WriteLine("For key = "rtf", value = {0}.", 
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = "rtf", value = {0}.", 
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the dictionary.
        try
        {
            Console.WriteLine("For key = "tif", value = {0}.", 
                openWith["tif"]);
        }
        catch (KeyNotFoundException)
        {
            Console.WriteLine("Key = "tif" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the dictionary, TryGetValue can be a more efficient 
        // way to retrieve values.
        string value = "";
        if (openWith.TryGetValue("tif", out value))
        {
            Console.WriteLine("For key = "tif", value = {0}.", value);
        }
        else
        {
            Console.WriteLine("Key = "tif" is not found.");
        }

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = "ht": {0}", 
                openWith["ht"]);
        }

        // When you use foreach to enumerate dictionary elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( KeyValuePair<string, string> kvp in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", 
                kvp.Key, kvp.Value);
        }

        // To get the values alone, use the Values property.
        Dictionary<string, string>.ValueCollection valueColl =
            openWith.Values;

        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for dictionary values.
        Console.WriteLine();
        foreach( string s in valueColl )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        Dictionary<string, string>.KeyCollection keyColl =
            openWith.Keys;

        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for dictionary keys.
        Console.WriteLine();
        foreach( string s in keyColl )
        {
            Console.WriteLine("Key = {0}", s);
        }

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("
Remove("doc")");
        openWith.Remove("doc");

        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key "doc" is not found.");
        }
    }
}


Postagem do dono do blog: (13/08/2014 22:46:23)
Usando HashTable em c#



Representa uma coleção de chave/valor pares que são organizados com base na código hash da chave.
Ou seja, se você precisa guardar valores e depois buscar eles por um nome identificador, use hashtable.

Segue exemplo:

using System;
using System.Collections;

class Example
{
    public static void Main()
    {
        // Create a new hash table.
        //
        Hashtable openWith = new Hashtable();

        // Add some elements to the hash table. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is 
        // already in the hash table.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch
        {
            Console.WriteLine("An element with Key = "txt" already exists.");
        }

        // The Item property is the default property, so you 
        // can omit its name when accessing elements. 
        Console.WriteLine("For key = "rtf", value = {0}.", openWith["rtf"]);

        // The default Item property can be used to change the value
        // associated with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = "rtf", value = {0}.", openWith["rtf"]);

        // If a key does not exist, setting the default Item property
        // for that key adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = "ht": {0}", openWith["ht"]);
        }

        // When you use foreach to enumerate hash table elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( DictionaryEntry de in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", de.Key, de.Value);
        }

        // To get the values alone, use the Values property.
        ICollection valueColl = openWith.Values;

        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for hash table values.
        Console.WriteLine();
        foreach( string s in valueColl )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        ICollection keyColl = openWith.Keys;

        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for hash table keys.
        Console.WriteLine();
        foreach( string s in keyColl )
        {
            Console.WriteLine("Key = {0}", s);
        }

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("
Remove("doc")");
        openWith.Remove("doc");

        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key "doc" is not found.");
        }
    }
}



Postagem do dono do blog: (10/08/2014 21:08:23)

Exemplo de como usar o foreach em c#


Esse comando serve para varrer um controle e/ou objeto, veja como fazer sem o foreach:

        for (int i = 0; i < fibarray.Length; i++)
        {
            System.Console.WriteLine(fibarray[i]);
        }
        System.Console.WriteLine();


Veja com o foreach:

 int[] fibarray = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 };
        foreach (int element in fibarray)
        {
            System.Console.WriteLine(element);
        }
        System.Console.WriteLine();


Postagem do dono do blog: (10/08/2014 21:02:43)
Como fazer para resgatar valores do arquivo Web.Config 


Primeiramente devemos importar o Namespace Configuraton. Depois utilizamos a Propriedade AppSettings da classe ConfigurationSettings passando como parâmetro o nome da Key à ser resgatada. 




>>>