Códigos Hexadecimal da Cor 

Esta página demonstra a representação de seis dígitos hexadecimais da cor na forma # RRGGBB, onde RR, GG e BB são os valores hexadecimais para o vermelho, verde, azul. Usar um código hexadecimal é a mais confiável maneira de definir cores em páginas HTML ou arquivos de estilo (CSS).

Fonte: December.com

Para facilitar um pouco, extraí tudo para uma planilha Excel que pode ser baixada aqui.

A cada lançamento do Visual Studio, normalmente são apresentadas novas características tanto no seu IDE, quanto no suporte de linguagens de programação. O vice-presidente da divisão de desenvolvimento da Microsoft apresentou recentemente quais as mudanças que vão entrar no Visual Studio 11.

A nova versão dará pleno reconhecimento à linguagem JavaScript, assim como faz com as linguagens C#, Visual Basic e C++. As melhorias para JavaScript também incluem suporte para a linguagem ECMAScript 5 como padrão, e o suporte para remover bugs para JavaScript agora coincide com o que está previsto outras linguagens do Visual Studio, incluindo janelas de remover bugs que suportam interagir com o aplicativo que está sendo debugado. Talvez, a novidade mais interessante seja a adição de um REPL (Read-Evaluate-Print Loop) para o desenvolvimento JavaScript.

O suporte de programação assíncrona serão integrados ao C # 5 e ao Visual Basic 11. O uso de código assíncrono em versões anteriores do Visual Studio foi difícil de se implementar e debugar. No Visual Studio 11, ambas as áreas serão melhoradas, fornecendo novos recursos de linguagem que permitem o uso de fluxos de controle tradicionais (loops, condicionais etc) com código assíncrono e inclui a capacidade de debugar essas declarações com o removedor de bugs integrado.

O desenvolvimento com C++ deve receber diversas melhorias notáveis na nova versão, como, por exemplo, melhor suporte IDE e a capacidade de construir aplicativos nativos do Windows Metro. Há uma maior ênfase no suporte para escrever o código paralelo utilizando o C++ e a tecnologia AMP (Accelerated Massive Parallelism). O Visual Studio 11 permite debugar diretamente os aplicativos usando o C++ e a AMP.

A nova versão do Visual Studio vai introduzir o F# 3.0 e a funcionalidade Type Provider. Esse mecanismo tem evoluído em resposta à necessidade de ligar linguagens estaticamente tipadas (F #) para os dados cada vez mais dinâmicos encontrados na web. O F# 3.0 terá suporte para Odata, WSDL e SQL, mas provedores customizados podem ser escritos.

Fonte: iMasters

Links relacionados:

• Download Visual Studio 11 Developer Preview
• Download Visual Studio 11 Developer Preview Training Kit
• Novidades do Visual Studio 11 Developer Preview

Para mais informações sobre o evento ou para realizar a inscrição, acesse o site oficial.

É muito bom ver Barra Bonita entrando para o cenário de TI nacional.

Minha inscrição já está feita!

Companhia criou um serviço que vai mapear API do iOS para o Windows Phone API.

O Windows Phone 7 (WP7) tem apenas seis meses e já tem mais de 12 mil aplicativos. Mas ainda é pouco quando comparado com o iPhone e outros dispositivos iOS, que têm mais de 300 mil apps disponíveis.

Quando desenvolvedores procuram uma nova plataforma de desenvolvimento, existem várias questões que devem ser respondidas. Uma delas é se vale a pena o trabalho de aprender uma nova linguagem e um novo conjunto de APIs. A Microsoft está tentando tornar isso menos problemático.

Cerca de 46% dos desenvolvedores em uma pesquisa da Appcellerator, alegam que já estão muito ocupados com as plataformas do iOS e Android.

A Microsoft lançou um serviço – de acordo com o Windows Team Blog – que irá mapear a API do iOS  para o Windows Phone API. Claro que não será possível executar o código e criar o aplicativo desenvolvido para o Windows Phone, mas ele possibilita a visualização do recurso na API do iOS e a descoberta do mesmo recurso no Windows Phone. Ao detalhar os métodos de uso nas APIs, a ferramenta fornecerá o código de exemplo. Tudo está ligado ao site do MSDN, que dá detalhes completos sobre o item estudado.

Isso não vai fazer com que uma onda maciça de desenvolvedores iOS lancem apps para o Windows Phone, mas vai ajudar aqueles que estão considerando a questão e facilitar a vida daqueles que já começaram os desenvolvimentos.

Fonte: ITWeb

Este service pack resolve problemas que foram encontrados através de uma combinação de clientes e de parceiros Microsoft, bem como testes internos. Este pacote oferece aos usuários do Visual Studio melhorias na estabilidade, agilidade e desempenho. O feedback recebido durante o lançamento da versão beta será utilizado para entregar uma versão final do service pack.

Fonte: Microsoft

Um dos benefícios do uso de múltiplas threads em uma aplicação é que cada uma delas é executado de forma assíncrona. Em aplicações desktop, isto permite que tarefas que consomem muito tempo possam ser executadas em segundo plano enquanto a janela do aplicativo e os controles continuam respondendo. Para aplicações em servidores, múltiplas tarefas fornecem a capacidade de lidar com cada solicitação de entrada com uma thread diferente, caso contrário, cada novo pedido não será atendido até que o pedido anterior tenha completado.

No entanto, a natureza assíncrona de threads significa que o acesso a recursos compartilhados, como arquivos, conexões de rede e memória devem ser sincronizados. Caso contrário, duas ou mais threads podem acessar o mesmo recurso ao mesmo tempo, e cada um desconhece a atuação da outra ação e o resultado é a corrupção de dados imprevisível e possíveis deadlocks.

Há algum tempo, fiz outros artigos que demonstram o uso de threads em C# e Visual Basic. Você pode encontrá-los aqui:

• Programando Threads em C# e VB.NET
• Passagem de parâmetros para Threads
• Programando Threads em C# – iMasters
• Recebendo retornos de threads em C# – iMasters

Lock e SyncLock

O Lock (C#) e o SyncLock (VB.NET) são declarações que podem ser utilizadas para garantir que um bloco de código seja executado até sua conclusão, prevenindo a interrupção da execução por outras threads. Essas declarações são interpretadas pelo compilador como bloqueios para um determinado objeto em um bloco de códigos. Se outra thread tenta executar o código envolvido pelo lock / SyncLock, ela esperará até que a primeira thread termine a execução e libere o objeto / código bloqueado.

//C#
public class LockTest
{
    public void TestarLock()
    {
        lock (this)
        {
            // Código que estará protegido pelo lock.
        }
    }
}

'VB.NET
Public Class LockTest
    Public Sub TestarLock()
        SyncLock Me
            ' Código que estará protegido pelo lock.
        End SyncLock
    End Sub
End Class

Sincronização de Eventos e Wait Handles

Existem dois tipos de sincronização: AutoResetEvent e ManualResetEvent. Eles diferem apenas na medida em que as mudanças são setadas automaticamento no AutoResetEvent e manualmente no ManualResetEvent. O ManualResetEvent permite que qualquer número de threads possa ser alinhado e ter seu estado atualizado.

Métodos são usados para esperar a execução de um ou mais threads. Esses métodos indicam ao compilador quando e quantas threads devem ter o processamento concluído para que o fluxo continue. São eles: WaitOne, WaitAny e WaitAll. WaitOne faz com que o compilador espere a execução de um único thread estar concluída. WaitAny faz o compilador aguardar a execução dos métodos indicados. WaitAll bloqueia a execução até que todas as threads estejam concluídas. Para sinalizar a conclusão da execução de uma thread usa-se o método Set.

// C#
namespace GerenciaSincronizacao
{
    public class GerenciarThreads
    {
        private ManualResetEvent[] manualResetEvent;

        private void ExecutarThread0(object obj)
        {
            Thread.Sleep(20000);
            Console.WriteLine("Thread 0 concluída!");
            manualResetEvent[0].Set();
        }

        private void ExecutarThread1(object obj)
        {
            Thread.Sleep(13000);
            Console.WriteLine("Thread 1 concluída!");
            manualResetEvent[1].Set();
        }

        private void ExecutarThread2(object obj)
        {
            Thread.Sleep(9000);
            Console.WriteLine("Thread 2 concluída!");
            manualResetEvent[2].Set();
        }

        private void ExecutarThread3(object obj)
        {
            Thread.Sleep(17000);
            Console.WriteLine("Thread 3 concluída!");
            manualResetEvent[3].Set();
        }

        public void Executar()
        {
            manualResetEvent = new ManualResetEvent[4];

            manualResetEvent[0] = new ManualResetEvent(false);
            ThreadPool.QueueUserWorkItem(this.ExecutarThread0);

            manualResetEvent[1] = new ManualResetEvent(false);
            ThreadPool.QueueUserWorkItem(this.ExecutarThread1);

            manualResetEvent[2] = new ManualResetEvent(false);
            ThreadPool.QueueUserWorkItem(this.ExecutarThread2);

            manualResetEvent[3] = new ManualResetEvent(false);
            ThreadPool.QueueUserWorkItem(this.ExecutarThread3);

            WaitHandle.WaitAll(manualResetEvent);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            GerenciarThreads gt = new GerenciarThreads();
            gt.Executar();

            Console.WriteLine("Pressione ENTER para terminar.");
            Console.ReadKey();
        }
    }
}

' VB.NET
Namespace GerenciaSincronizacao
    Public Class GerenciarThreads
        Private manualResetEvent As ManualResetEvent()

        Private Sub ExecutarThread0(obj As Object)
            Thread.Sleep(20000)
            Console.WriteLine("Thread 0 concluída!")
            manualResetEvent(0).[Set]()
        End Sub

        Private Sub ExecutarThread1(obj As Object)
            Thread.Sleep(13000)
            Console.WriteLine("Thread 1 concluída!")
            manualResetEvent(1).[Set]()
        End Sub

        Private Sub ExecutarThread2(obj As Object)
            Thread.Sleep(9000)
            Console.WriteLine("Thread 2 concluída!")
            manualResetEvent(2).[Set]()
        End Sub

        Private Sub ExecutarThread3(obj As Object)
            Thread.Sleep(17000)
            Console.WriteLine("Thread 3 concluída!")
            manualResetEvent(3).[Set]()
        End Sub

        Public Sub Executar()
            manualResetEvent = New ManualResetEvent(3) {}

            manualResetEvent(0) = New ManualResetEvent(False)
            ThreadPool.QueueUserWorkItem(AddressOf Me.ExecutarThread0)

            manualResetEvent(1) = New ManualResetEvent(False)
            ThreadPool.QueueUserWorkItem(AddressOf Me.ExecutarThread1)

            manualResetEvent(2) = New ManualResetEvent(False)
            ThreadPool.QueueUserWorkItem(AddressOf Me.ExecutarThread2)

            manualResetEvent(3) = New ManualResetEvent(False)
            ThreadPool.QueueUserWorkItem(AddressOf Me.ExecutarThread3)

            WaitHandle.WaitAll(manualResetEvent)
        End Sub
    End Class

    Class Program
        Private Shared Sub Main(args As String())
            Dim gt As New GerenciarThreads()
            gt.Executar()

            Console.WriteLine("Pressione ENTER para terminar.")
            Console.ReadKey()
        End Sub
    End Class
End Namespace

A classe Interlocked

Você pode usar os métodos da classe Interlocked para evitar problemas que podem ocorrer quando várias threads tentam simultaneamente atualizar ou comparar um mesmo valor. Os métodos dessa classe permitem que você assegure o incremento, decremento, troca e comparação entre valores em qualquer thread.

As operações mais utilizadas desta classe são:

• O método Add adiciona um valor inteiro para uma variável e retorna o novo valor da variável.
• O método Read lê um valor inteiro de 64 bits.
• Os métodos Increment e Decrement são utilizados para incrementar ou decrementar valores em uma variável e retornam o valor resultante.

O código a seguir demonstra o uso do Increment.

// C#
private static ManualResetEvent[] manualResetEvents;

public void Teste()
{
    int intQuantidadeInteracoes = 10;
    int intContador = 0;

    manualResetEvents = new ManualResetEvent[intQuantidadeInteracoes];

    for (int i = 0; i < intQuantidadeInteracoes; i++)
    {
        manualResetEvents[intContador] = new ManualResetEvent(false);

        ThreadPool.QueueUserWorkItem(this.Executar, intContador);

        Interlocked.Increment(ref intContador);
    }

    WaitHandle.WaitAll(manualResetEvents);
}

public void Executar(object intContador)
{
    Console.WriteLine("Posição atual do contador: {0}",
        Convert.ToInt32(intContador));

    manualResetEvents[Convert.ToInt32(intContador)].Set();
}

' VB.NET
Private Shared manualResetEvents As ManualResetEvent()

Public Sub Teste()
    Dim intQuantidadeInteracoes As Integer = 10
    Dim intContador As Integer = 0

    manualResetEvents = New ManualResetEvent(intQuantidadeInteracoes - 1) {}

    For i As Integer = 0 To intQuantidadeInteracoes - 1
        manualResetEvents(intContador) = New ManualResetEvent(False)

        ThreadPool.QueueUserWorkItem(AddressOf Me.Executar, intContador)

        Interlocked.Increment(intContador)
    Next

    WaitHandle.WaitAll(manualResetEvents)
End Sub

Public Sub Executar(intContador As Object)
    Console.WriteLine("Posição atual do contador: {0}", Convert.ToInt32(intContador))

    manualResetEvents(Convert.ToInt32(intContador)).[Set]()
End Sub

Referências

• Thread Synchronization (C# and Visual Basic)
• Thread Synchronization (C# Programming Guide)
• SyncLock Statement
• lock Statement (C# Reference)
• Interlocked Operations
• AutoResetEvent

Os métodos de extensão surgiram junto com o .Net Framework 3.5, e permitem adicionarmos novas funcionalidades a tipos existentes, sem a necessidade de alterar o tipo original e recompilá-lo. Devem sempre ser métodos estáticos, mas a chamada para eles é muito parecida com a chamada para métodos de instância. O primeiro parâmetro especifica em qual o tipo que método opera e deve sempre ser seguido da palavra chave this.

A classe que conterá o método de extensão, assim como o próprio método, também deve ser estática e a Namespace deve ser declarada nos locais onde o método de extensão deverá ficar disponível, através de using.

OBS: Todos os códigos contidos neste artigo estão em Linguagem C#

Vejamos um exemplo de criação método de extensão:

// C#
public static class MetodosDeExtensao
{
    /// <summary>
    /// Verifica se um objeto é nulo
    /// </summary>
    /// <param name="obj">object, objeto a ser verificado</param>
    /// <returns>bool, true quando o objeto for nulo</returns>
    public static bool IsNull(this object obj)
    {
        if (obj == null)
            return true;
        else
            return false;
    }
}

No exemplo acima, fizemos um método de extensão que verifica se um objeto é nulo ou não. É possível ver a palavra chave this antes a declaração do primeiro parâmetro do método, que é o identificador do tipo onde o método de extensão será aplicado.

O método em sí, terá a mesma estrutura de qualquer outro método estático, ou seja, não muda nada na forma de desenvolvimento e poderá ser usado normalmente como um método estático. Veja:

// C#
// utilizando a maneira convencional
string strNome = "Fernando Ottoboni";
if (MetodosDeExtensao.IsNull(strNome))
    Console.WriteLine("Nome não informado.");

Mas já que estamos falando de métodos de extensão, vamos então ver a forma correta de utilização do mesmo.

A partir do momento que o método de extensão foi criado, em todos os locais onde a namespace estiver acessível (lembre-se do using), o tipo declarado no método passará a conter uma nova extensão. Veja:

A seguir é possível ver um exemplo da sintaxe completa de utilização do nosso método de extensão.

// C#
// utilizando o método de extensão
string strNome = "Fernando Ottoboni";
if (strNome.IsNull())
    Console.WriteLine("Nome não informado.");

Em algumas situações, precisamos fazer métodos que devem ter dois ou mais parâmetros de entrada. Isso também é possível em métodos de extensão, mas devemos lembrar que sempre precisamos colocar o this no primeiro parâmetro (sempre no primeiro e somente nele). Os parâmetros restantes serão parâmetros comuns. Vejamos um exemplo:

// C#
/// <summary>
/// Completa a string com a quantidade e o caracter informado
/// </summary>
/// <param name="str">String, string a ser completada</param>
/// <param name="caracter">String, caracter a ser usado ao completar</param>
/// <param name="qt">Int, quantidade de caracteres</param>
/// <returns>String, string completada com os caracters</returns>
public static string CompletarString(this string str, string caracter, int qt)
{
    if (string.IsNullOrEmpty(str))
        str = "";

    if (caracter.Length > 1)
        caracter = caracter.Substring(0, 1);

    StringBuilder stb = new StringBuilder();

    if (string.IsNullOrEmpty(caracter.ToString()))
        caracter = " ";

    if (qt - str.Length > 0)
    {
        qt = qt - str.Length;
        stb.Append(str);
        stb.Append(new String(Convert.ToChar(caracter), qt));
    }
    else
    {
        stb.Append(str.Substring(0, qt));
    }

    return stb.ToString();
}

Existem várias outras situações e cenários onde podemos usar métodos de extensão. Vejamos então alguns lugares interessantes:

• IsNullOrEmpty

Adquiri tão rapidamente o costume de usar métodos de extensão, que tive que fazer tornar o IsNullOrEmpty (String.IsNullOrEmpty) um deles apenas por conveniência.

// C#
/// <summary>Verficar se uma string é nula ou vazia</summary>
public static bool IsNullOrEmpty(this string str)
{
    return string.IsNullOrEmpty(str);
}

• IsNullOrWhiteSpace

Assim como os IsNullOrEmpty, o mesmo pode ser feito com o IsNullOrWhiteSpace (String.IsNullOrWhiteSpace).

// C#
/// <summary>
/// Verficar se uma string é nula ou espaço em branco
/// </summary>
public static bool IsNullOrWhiteSpace(this string str)
{
    return string.IsNullOrWhiteSpace(str);
}

• IsDateTime

Verificar se um string é um DateTime válido.

// C#
/// <summary>
/// Verificar se o conteúdo da string equivale a um DateTime
/// </summary>
public static bool IsDateTime(this string str)
{
    string strData = str;

    if (string.IsNullOrEmpty(strData))
        return false;

    try
    {
        DateTime datData = Convert.ToDateTime(strData);
        return true;
    }
    catch
    {
        return false;
    }
}

• IsDecimal

Verificar se um string é um Decimal válido.

// C#
/// <summary>
/// Verificar se o conteúdo da string equivale a um decimal.
/// </summary>
public static bool IsDecimal(this string str)
{
    if (String.IsNullOrEmpty(str))
        return false;

    try
    {
        Convert.ToDecimal(str);
        return true;
    }
    catch
    {
        return false;
    }
}

• ReverseString

Retorna a string reversa.

// C#
/// <summary>
/// Retorna a string de forma reversa
/// </summary>
/// <param name="str">String a ser revertida</param>
/// <returns>String revertida</returns>
public static string ReverseString(this string str)
{
    char[] arr = str.ToCharArray();
    Array.Reverse(arr);
    return new string(arr);
}

• Left

Extrai um Substring do lado esquerdo da string conforme a quantidade de caracteres desejada.

// C#
/// <summary>
/// Extrai um Substring do lado esquerdo da string
/// conforme a quantidade de caracteres desejada
/// </summary>
/// <param name="str">String para extrair o substring</param>
/// <param name="length">Quantidade de caracteres a extrair</param>
/// <returns>String</returns>
public static string Left(this string str, int length)
{
    if (str.IsNullOrEmpty())
        return str;

    if (str.Length <= length)
        return str;

    return str.Substring(0, length);
}

• Right

Extrai um Substring do lado direito da string conforme a quantidade de caracteres desejada.

OBS: Usa o método ReverseString.

// C#
/// <summary>
/// Extrai um Substring do lado direito da string conforme a quantidade de caracteres desejada
/// </summary>
/// <param name="str">String para extrair o substring</param>
/// <param name="length">Quantidade de caracteres a extrair</param>
/// <returns>String</returns>
public static string Right(this string str, int length)
{
    if (str.IsNullOrEmpty())
        return str;

    if (str.Length <= length)
        return str;

    return str.ReverseString().Substring(0, length).ReverseString();
}

Existem muitas outras possibilidades, e no código fonte que pode ser baixado logo abaixo coloquei alguns outros exemplos.

LINQ e os Métodos de Extensão

Há algum tempo, fiz um artigo que mostrei como utilizar e como funcionam os métodos de extensão disponíveis para utilização com LINQ. Se quiser conferir, basta clicar aqui.

Códigos fontes

Os códigos-fontes deste artigo podem ser baixados aqui.

Referências

• Extension Methods (C# Programming Guide)

Recebendo retornos de threads em C#

Existem situações em que é necessário retornar informações quando a execução da thread estiver concluída para que elas sejam usadas na continuação do processamento da thread principal da aplicação. O intuito deste artigo é mostrar uma maneira de receber e tratar retornos de threads.

Neste link: imasters.com.br/artigo/19615/c-sharp/recebendo-retornos-de-threads-em-c

Vale a pena conferir!

Obrigado.

Para conseguir rodar o WCF Test Client em computadores que não tem o Visual Studio, basta copiar os seguintes arquivos da pasta C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE. [este endereço pode variar conforme a instalação do VS em seu computador.]

• SvcUtil.exe
• SvcUtil.exe.config
• WcfSvcHost.chm
• WcfSvcHost.exe
• WcfSvcHost.exe.config
• WcfTestClient.chm
• WcfTestClient.exe
• WcfTestClient.exe.config

Para fazer download dos arquivos, acesse os links a seguir:

• WcfTestClient do VS2008
• WcfTestClient do VS2010

Referência:

• Info: Running WcfTestClient Tool in a PC without VS.Net 2008

string strQuery = (qLinq as ObjectQuery).ToTraceString();
// é necessário: using System.Data.Objects;

Exemplo:

Linq:

var qLinq = from t in c.TABELAs
            where t.CAMPO1 < i
            select t;

Lambda:

var qLambda = c.TABELAs.Where(t => t.CAMPO1 < i);

Query SQL Gerada:

SELECT
       [Extent1].[CAMPO1] AS [CAMPO1],
       [Extent1].[CAMPO2] AS [CAMPO2]
  FROM [dbo].[TABELA] AS [Extent1]
 WHERE [Extent1].[CAMPO1] < @p__linq__1

OBS: A Sql gerada é igual tanto para a Query Linq quanto para a Lambda Expression.

Essa dica foi o Marquinhos que me passou.

Programando threads em C#

Usar threads é sempre vantajoso no ponto de vista de que podemos aproveitar o poder de processamento dos processadores que possuem mais de um núcleo, pois podemos programar para que cada thread tenha o seu processamento realizado por núcleos diferentes.

Neste link: http://imasters.com.br/artigo/19541/csharp/programando_threads_em_c/

Obrigado.

É crescente a quantidade de empresas que analisam a possibilidade de adoção da computação nas nuvens, por conta da flexibilidade de gestão que o ambiente proporciona.

No início se falava em nuvens públicas, cujos equipamentos, infraestrutura e aplicações são compartilhados por milhares de usuários em todo o mundo, por intermédio da internet. Um bom exemplo de nuvem pública é o que o Google implementa, com servidores instalados em vários lugares do mundo.

Hoje, se fala muito em nuvens privadas, ambiente dentro da própria empresa, com segurança maior, e com acesso restrito a pessoas autorizadas, geralmente funcionários. No entanto, as nuvens privadas também têm sua dose de desafios e eles não estão restritos apenas à segurança. A dificuldade de gerenciar pode ser uma barreira, sem contar com a preparação necessária para migrar os ambientes tradicionais de TI para cloud computing.

Para o usuário, deve ser transparente o fato de a nuvem ser pública ou privada. Uma das desvantagens das nuvens públicas sobre as nuvens privadas é por não fornecerem a segurança e a privacidade de informações que muitas empresas necessitam.

Na perspectiva de muitos gestores de TI, a nuvem equivale a uma solução de virtualização. Normalmente, o que dizem ser um projeto de cloud computing nada mais é do que uma estrutura virtual, ou seja, com os equipamentos e sistemas compartilhando recursos sob demanda. Virtualização e nuvem, no entanto, são coisas distintas.

Vejamos alguns benefícios e riscos da computação em nuvens:

Benefícios:

• A computação em nuvem pode ser mais uma ferramenta nas mãos da equipe de TI, ajudando a suprir as necessidades do negócio de forma criativa, mais rápida e eficiente, especialmente se unida aos recursos internos de datacenter.
• A computação em nuvem oferece o potencial para recursos variáveis de computação, permitindo que as empresas diminuam os gastos da área de TI para o essencial e fiquem mais confiantes para enfrentar demanda de pico.
• Mais rapidez para as ofertas do mercado com potenciais vantagens de estratégia, com baixo custo total como vantagem operacional crítica.

Riscos:

• Algumas cargas de trabalho não têm sentido em computação em nuvem. As equipes de TI precisam estar preparadas para mudar a organização e as habilidades necessárias, mas também manter a empresa longe das estratégias de risco.
• Interrupções e perda de dados são os maiores riscos. A nuvem requer novos relacionamentos com fornecedores, entendimento absoluto da segurança oferecida e mais ênfase no monitoramento da experiência do usuário final.

À medida que a computação em nuvem evolui, como todo caso de implantação de tecnologias recentes, as empresas se deparam com questões pouco exploradas, como a necessidade de integrar os diferentes ambientes de TI. Isso porque, as perspectivas são de que as corporações atuem, cada vez mais, com modelos híbridos, uma união entre nuvem pública e nuvem privada, nos quais sistemas instalados no datacenter da companhia conversem com fornecedores terceirizados e com provedores de cloud computing.

Conclusão

A computação em nuvem está em estágio inicial de adoção e conforme ela vai ganhando espaço, soluções aparecerão para os problemas atuais. Os líderes de TI devem antecipar como ela poderá mudar a TI, as habilidades necessárias e as relações de negócio a fim de extrair todo o potencial oferecido pela nuvem.

__________________________________________

OBS: Este artigo foi escrito como trabalho a ser entregue na disciplina Gestão de Tecnologia da Informação do curso de Inteligência de Negócios da Faculdade de Tecnologia de Jaú – FATEC.

Referências

• Wikipédia – Computação em Nuvens
• Financial Web: O impacto da computação em nuvem para a empresa
• Microsoft Cloud Power
• Microsoft Windows Azure: Cloud Services Plataform

Obrigado e até mais!

O que o Milton disse no comentário dele foi:

Realmente a diferença é brutal. A forma de trabalho das strings faz com que a mesma seja mais lerda, isso pq sempre que concatenamos o compilador gera um novo array de char com o tamanho final (antigo + tamanho concatenado)

…..

Vamos as explicações

Toda vez que o conteúdo de uma string é alterado, um novo objeto string é criado na memória, o que requer uma nova alocação de espaço para esse novo objeto. Em situações onde é necessários realizar repetidas modificações em uma string (como o caso do exemplo que dei no meu post), a sobrecarga associada à criação de um novo string pode ter um custo caro, tanto em tempo de execução, quanto em uso de memória. O StringBuilder pode ser usado para esses casos de necessidade de modificar strings sem criar um novo objeto.

O StringBuilder representa uma sequência de caracteres cujo valor pode ser modificado. Dizer que o valor pode ser modificado significa que pode ser alterado depois de ter sido criado, acrescentando, removendo ou substituindo caracters.

O desempenho de uma operação de concatenação de um String ou StringBuilder depende da freqüência na qual a alocação de memória ocorre. Como já disse, um string sempre aloca memória a cada concatenação (alteração). Já com o StringBuilder, a operação de concatenação aloca memória apenas para os novos conteúdos adicionados. Consequentemente, string é preferível para operações de concatenação com um número fixo de objetos a serem concatenados. Nesse caso, as operações de concatenação são combinadas em uma única operação pelo compilador.  Já o StringBuilder é preferível para uma operação de concatenação quando um número grande de concatenações devem ser realizadas.

Membros importantes do StringBuilder

• Construtor StringBuilder(): Inicializa uma nova instância da classe StringBuilder.
• Método Append(): Concatena um novo objeto à instância do StringBuilder. Existem vários overloads deste métodos, na qual vários tipos de dados podem ser usados, como Boolean, Int, Decimal, String, etc., não necessariamente strings.
• Método AppendLine(): Concatena um novo objeto à instância do StringBuilder e adiciona um terminador de linha ao final da concatenação.
• Método Clear(): Limpa o StringBuilder.
• Método Insert(): Insere o conteúdo especificado na posição desejada.
• Método Remove(): Remove o intervalo especificado de caracteres da instância do StringBuilder.
• Método Replace(): Substitui todas as ocorrências de um caractere especificado com outro caractere especificado.
• Método ToString(): Converte o conteúdo do StringBuilder para uma string comum.
• Propriedade Capacity: Obtém ou define a quantidade máxima de caracteres que podem ser contidos na memória alocada pela instância do StringBuilder.
• Propriedade Length: Obtém o comprimento da instância atual do StringBuilder.

Fontes

• Using the StringBuilder Class
• System.Text.StringBuilder

Este service pack beta resolve problemas que foram encontrados através de uma combinação de clientes e de parceiros Microsoft, bem como testes internos. Este pacote oferece aos usuários do Visual Studio melhorias na estabilidade, agilidade e desempenho. O feedback recebido durante o lançamento da versão beta será utilizado para entregar uma versão final do service pack.

Fonte: Microsoft

O Downlod pode ser feito através deste link.

Fonte: Jason Zander’s WebLog

Há alguns dias fui questionado sobre isso e na hora me veio a idéia de fazer um teste para comparação.

Conceitos

StringBuilder: http://msdn.microsoft.com/en-us/library/2839d5h5(v=VS.100).aspx

String: http://msdn.microsoft.com/en-us/library/362314fe(v=VS.100).aspx

Vamos ao Teste

Fiz um pequeno programa que simula uma grande quantidade de concatenações ou appends em StringBuilders. A idéia é um bloco for que concatena uma string várias vezes e outro bloco for que faz vários appends em um StringBuilder. Algo desse tipo:

// Várias concatenações na string
string str = string.Empty;
for (int i = 1; i <= qt; i++)
    str = str + " Concatenação nº " + i.ToString();

// Vários appends no StringBuilder
StringBuilder stb = new StringBuilder();
for (int i = 1; i <= qt; i++)
{
    stb.Append(" Append nº ");
    stb.Append(i.ToString());
}

O resultado foi de impressionar. Veja:

No teste, executei 100.000 concatenações/appends, e o tempo de execução das concatenações foi absurdamente maior que o tempo de execução dos appends.

Portanto, a partir de agora, use StringBuilder em vez de strings comuns.

O código fonte pode ser baixado aqui.

Valeu galera!

• Testes rápidos com o WCF Test Client
• Programando Threads em C# e VB.NET
• LINQ com Entity Framework – INCLUDE
• Como assinar Feeds RSS
• LINQ e Lambda Expression: OrderBy em vários campos
• Entity Framework + TransactionScope
• Exemplo de Implementação de IDisposable
• Trabalhando com tipos anuláveis
• A Internet como ferramenta de TI
• LINQ Extensions

Obrigado.

select owner "Owner",
       object_name "Objeto",
       status "Estado"
  from dba_objects
 where lower(status) != 'valid'
   and lower(owner) = '{nome_do_owner}'
   -- a linha acima pode ser eliminada para
   -- que todos os objetos inválidos sejam
   -- listados, independente do owner
 order by owner, object_name;

select * from v$version

Resultado:

Estou participando de um projeto na qual utilizamos o Entity Framework para criação ORM (ou MOR – Modelo Objeto Relacional) de acesso ao banco de dados. Durante o desenvolvimento o cliente nos informou que a string de conexão com o banco de produção nos seria passada apenas através de uma DLL. Ou seja, não teríamos uma string de conexão propriamente dita no arquivo .config, e sim apenas um “esboço” dela.

A Connection String com todos os parâmetros preenchidos fica na DLL, por isso, no arquivo de configuração fica uma constante {CONST_CONNECTIONSTRING} que será substituída pela ConnectionString real.

A DLL contém um método estático que retorna a string de conexão. Para simular, vamos imaginar uma ClassLibrary com uma classe parecida com essa:

public class ConnectionString
{
    public static string GetConnectionString()
    {
        return "Data Source=.;
                Initial Catalog=TESTEEF;
                Integrated Security=True;
                MultipleActiveResultSets=True";
    }
}

Quando vamos criar uma instância do ObjectContext do Entity Framework, temos um construtor que nos permite passar a string de conexão que desejamos utilizar. Mas nesse caso, temos parte da string de conexão no arquivo de configuração e outra parte em uma DLL. Para resolver isso, fiz um outro método estático que “junta” as duas coisas:

public static string GetCompleteConnectionString(string strConnectionName)
{
    string strConnectionString = string.Empty;

    try
    {
        strConnectionString =
            ConfigurationManager.ConnectionStrings[strConnectionName]
            .ConnectionString;
        // é necessário: using System.Configuration;
    }
    catch
    {
        strConnectionString = string.Empty;
    }

    if (string.IsNullOrEmpty(strConnectionString))
        throw new Exception("ConnectionString não encontrada.");

    return strConnectionString.Replace("{CONST_CONNECTIONSTRING}",
        ConnectionString.ConnectionString.GetConnectionString());
}

Agora, para criar o ObjectContext usando a Connection String correta, basta usar o construtor que permite passar a string como parâmetro.

using (Entidades e =
    new Entidades
        (GerenciarConnectionString.GetCompleteConnectionString("Entidades")))
{

}

Pronto, terminamos! Mas ainda tem um “porém”. Quando estava desenvolvendo pensei o seguinte: “Vou ter que passar a ConnectionString em todos os lugares onde crio uma instância do ObjectContext? E se em algum eu passar o nome da ConnectionString errado?”. Para resolver isso, criei um novo construtor para a classe que representa o ObjectContext na qual eu sempre pego a ConnectionString através do método GetCompleteConnectionString que mostrei acima. Isso só é possível pelo fato da classe que representa o ObjectContext ser partial.

A classe parcial com o novo construtor ficou assim:

public partial class Entidades : global::System.Data.Objects.ObjectContext
{
    public Entidades(bool bolBuscarConnectionStringCorreta) :
        base(GerenciarConnectionString.GetCompleteConnectionString("Entidades"),
        "Entidades")
    {
        if (!bolBuscarConnectionStringCorreta)
            throw new Exception("Este construtor permite apenas TRUE.");

        this.OnContextCreated();
    }
}

Feito isso, basta usar este novo construtor para a criação das instâncias do ObjectContext.

using (Entidades e = new Entidades(true))
{

}

É isso, galera! Espero que seja útil.

O código fonte pode ser baixado aqui.

Obrigado

Decifre: http://nickciske.com/tools/binary.php

O post pode lido aqui.

Muito obrigado Israel.

Um incomodo no Visual Studio 2010 é a janela “Find And Replace”, que segundo o Blog do Visual Studio, aumenta 16px a cada vez que é aberta. Para resolver este problema, foi liberado um Patch que fixa o tamanho da janela. Para instalar é muito simples e o download pode ser feito aqui.

Clique na imagem para visualizar.

Estava hoje procurando a solução de um erro ocorrido em uma conexão com um banco ORACLE e acabei encontrando um site muito interessante. Trata-se de um “Wikipédia” sobra Oracle e chama-se Oracle Wiki.

Veja que interessante: http://www.orafaq.com/wiki/

Programadores dispostos a desembolsar US$ 99 por ano para a App Hub poderão apresentar seus aplicativos para a loja.

A Microsoft anunciou programa para desenvolvedores produzirem aplicativos para o Windows Phone 7. As informações são de seu blog oficial.
Conforme o post, o envio das aplicações era feito apenas por convite. A partir de agora, programadores dispostos a desembolsar US$ 99 por ano para a App Hub poderão apresentar seus aplicativos para a loja.
A Microsoft leva de três a cinco dias para certificar e publicar um aplicativo.
Os membros da App Hub também terão um teste gratuito do serviço de analytics móvel da PreEmptive.
De acordo com o site Windows Phone 7 da empresa, os desenvolvedores terão acesso a informações como número de sessões da aplicação, número de usuários únicos, contagem e duração de uso da ferramenta e estatísticas de estabilidade.

Fonte: ITWeb

• Novidades do Visual Basic 10 por Alexandre Tarifa
• Windows 7: C# e Localização por André Nobre
• Desafio: O que você faria com 1000 Servidores durante 1hr? por Otavio Pecego Coelho
• Processamento 1000 vezes mais rápido por Otavio Pecego Coelho
• Sobrecarga de Operadores Aritméticos em C# por Agnaldo do blog 50minutos
• Desobediência é um problema por Giovanni Bassi
• Detectando mudanças em objetos por Israel Aece no Linha de Código
• Criando uma classe em runtime com Reflection por Luciano Lima
• Trabalhando com ObservableCollection por Márcio Fábio Althmann
• Cloud Computing para Arquitetos de TI – Private Cloud por Markus Christen
  • Introdução
  • Capacidades Infinitas
  • Previsibilidade
  • Provedor de Serviço de Infraestrutura (IaaS)
• Gerenciando serviços WCF RIA Services com o Windows Server AppFabric por Rafael Godinho
• Treinamento ASP.NET 4 Avançado por Renato Haddad
• Microsoft Sync Framework 4.0 October 2010 CTP por Renato Haddad
• Pensando sobre TI ao longo do tempo por Waldemir Cambiucci
• A SOA não morreu por Kleber Bacili
• 10 dilemas da segurança da informação no ITWeb

Obrigado e até mais.

Este post é curto, e é apenas para responder a uma pergunta que ouço com frequência.

Uma vez li um artigo do Caio Proiete intitulado “Como ser um desenvolvedor melhor?”.

Em um dos tópicos Caio diz:

Escreva artigos técnicos
Sim. Ao escrever artigos técnicos você se obriga a estudar mais sobre um assunto, e consequentemente aprenderá mais sobre esse assunto, e ainda terá a chance de aprender mais ainda ao receber as opiniões dos seus leitores. Iniciar o seu próprio blog pode ser uma boa maneira de começar, mas de qualquer forma, com ou sem blog, publique seus artigos em comunidades dedicadas ao assunto, como por exemplo o Linha de Código e PontoNetPT, entre outros, para ter uma audiência maior e qualificada.

Esta é uma das respostas para a pergunta: “Mas por que você resolveu ter um blog?”.

Obrigado e até mais!

O programa UPPERCASE DevelUPPER Training é uma iniciativa da UPPERCASE com o objetivo de prover capacitação profissional para jovens talentos, proporcionando adicionalmente a oportunidade de vivenciar o dia a dia de nossas equipes de projeto.

Fonte: UPPERCASE

Saiba mais:

• UPPERCASE DevelUPPER Training

OBS 1: Vou publicando aos poucos, por isso, diariamente teremos novidades neste artigo.

OBS 2: Para os exemplos, utilizarei como source várias coleções de objetos, conforme mostra o código a seguir:

// Classe Pessoa
public class Pessoa
{
    public int ID { get; set; }
    public string Nome { get; set; }
    public int Idade { get; set; }
    public Sexo Sexo { get; set; }
    public List<Animal> Animais { get; set; }
}

// Enumerador para Sexo
public enum Sexo
{
    Masculino,
    Feminino
}

// Classe Animal
public class Animal
{
    public int ID { get; set; }
    public Especie Especie { get; set; }
    public string Nome { get; set; }
    public Pessoa Dono { get; set; }
}

// Enumerador para Especie
public enum Especie
{
    Cachorro,
    Gato,
    Piriquito
}

// Criando o array de Pessoas
Pessoa[] Pessoas =
{
    new Pessoa
    { ID=1, Nome="José", Idade=28, Sexo=Sexo.Masculino },
    new Pessoa
    { ID=2, Nome="Antonio", Idade=22, Sexo=Sexo.Masculino},
    new Pessoa
    { ID=3, Nome="Maria", Idade=20, Sexo=Sexo.Feminino },
    new Pessoa
    { ID=4, Nome="Fernanda", Idade=32, Sexo=Sexo.Feminino },
    new Pessoa
    { ID=5, Nome="João", Idade=32, Sexo=Sexo.Masculino }
};
Animal[] Animais = CriarArrayDeAnimais(Pessoas);
foreach (Pessoa pessoa in Pessoas)
    pessoa.Animais = Animais.Where(a => a.Dono.ID == pessoa.ID).ToList();

// Segundo array de Pessoas
Pessoa[] OutrasPessoas =
{
    new Pessoa
    { ID=6, Nome="Josefina", Idade=12, Sexo=Sexo.Feminino },
    new Pessoa
    { ID=7, Nome="Antonieta", Idade=25, Sexo=Sexo.Feminino },
    new Pessoa
    { ID=8, Nome="Mário", Idade=22, Sexo=Sexo.Masculino },
};

// Array de Animais
Animal[] Animais =
{
    new Animal
    { ID=1, Especie=Especie.Cachorro, Nome="Fred", Dono=Pessoas[0] },
    new Animal
    { ID=2, Especie=Especie.Cachorro, Nome="Billy", Dono=Pessoas[0] },
    new Animal
    { ID=3, Especie=Especie.Cachorro, Nome="Pandora", Dono=Pessoas[1] },
    new Animal
    { ID=4, Especie=Especie.Cachorro, Nome="Teny", Dono=Pessoas[1] },
    new Animal
    { ID=5, Especie=Especie.Cachorro, Nome="Cindy", Dono=Pessoas[1] },
    new Animal
    { ID=6, Especie=Especie.Piriquito, Nome="Crodô", Dono=Pessoas[2] },
    new Animal
    { ID=7, Especie=Especie.Piriquito, Nome="Frodo", Dono=Pessoas[2] },
};

Vamos lá, então!

Clique sobre o comando para ver detalhes:

• All
• Any
• AsEnumerable
• Average
• Concat
• Contains
• Count
• Distinct
• ElementAt
• ElementAtOrDefault
• Except
• First
• FirstOrDefault
• GroupBy
• GroupJoin
• Intersect
• Join
• Last
• LastOrDefault
• LongCount
• Max
• Min
• OrderBy
• OrderByDescending
• Reverse
• Select
• SelectMany
• SequenceEqual
• Single
• SingleOrDefault
• Skip
• SkipWhile
• Sum
• Take
• TakeWhile
• ThenBy
• ThenByDescending
• ToArray
• ToDictionary
• ToList
• Union
• Where

Código fonte

O download de todos os códigos pode ser feito aqui.

Saiba mais:

• Interface IQueryable
• Interface IEnumerable
• Interface IOrderedQueryable
• Namespace System.Linq
• Extension Methods
• C# Lambda Expression
• Enumerable Members

Where: Filtra a coleção com base na expressão lambda.

// Where: Filtra a coleção com base na expressão lambda.
var queryWhere = Pessoas.Where(p => p.Sexo == Sexo.Feminino);
Console.WriteLine("Pessoas do sexo Feminino:");
foreach (Pessoa p in queryWhere)
    Console.WriteLine(p.Nome);
// Resultado no console:
// Pessoas do sexo Feminino
// Maria
// Fernanda

Saiba Mais:

• Enumerable.Where<TSource> Method (IEnumerable<TSource>, Func<TSource, Boolean>)
• Enumerable.Where<TSource> Method (IEnumerable<TSource>, Func<TSource, Int32, Boolean>)

Union: Provoca a união entre duas coleções, ignorando os registros repetidos.

// Union: Provoca a união entre duas coleções,
//        ignorando os registros repetidos.
var queryUnion = Pessoas.Union(OutrasPessoas);
foreach (Pessoa p in queryUnion)
    Console.WriteLine(p.Nome);
// Resultado no console:
// José
// Antonio
// Maria
// Fernanda
// João
// Josefina
// Antonieta
// Mário

• Enumerable.Union<TSource> Method (IEnumerable<TSource>, IEnumerable<TSource>)
• Enumerable.Union<TSource> Method (IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

ToList: Converte o objeto para o tipo List.

// ToList: Converte o objeto para o tipo List.
List<Pessoa> listaDePessoas = Pessoas.ToList();
foreach (Pessoa p in listaDePessoas)
    Console.WriteLine(p.Nome);
// Resultado no console:
// José
// Antonio
// Maria
// Fernanda
// João

• Enumerable.ToList<TSource> Method

ToDictionary: Converte o objeto para o tipo Dictionary.

// ToDictionary: Converte o objeto para o tipo Dictionary.
Dictionary<int, Pessoa> dic = Pessoas.ToDictionary(p => p.ID);
foreach (var item in dic)
    Console.WriteLine("Nome: {0} | Identificação: {1}", item.Value.Nome, item.Key);
// Resultado no console:
// Nome: José | Identificação: 1
// Nome: Antonio | Identificação: 2
// Nome: Maria | Identificação: 3
// Nome: Fernanda | Identificação: 4
// Nome: João | Identificação: 5

ToArray: Converte o objeto para o tipo Array.

// ToArray: Converte o objeto para o tipo Array.
Pessoa[] Pessoas = ListaDePessoas.ToArray();
foreach (Pessoa p in Pessoas)
    Console.WriteLine(p.Nome);
// Resultado no console:
// José
// Antonio
// Maria
// Fernanda
// João

TakeWhile: Retornar elementos de uma coleção até que a condição da expressão lambda seja verdadeira.

// TakeWhile: Retornar elementos de uma coleção até 
//            que a condição da expressão lambda seja 
//            verdadeira
var queryTakeWhile = Pessoas.TakeWhile(p => p.Idade != 20);
foreach (Pessoa p in queryTakeWhile)
    Console.WriteLine("Nome: {0} | Idade: {1}", p.Nome, p.Idade.ToString());
// Resultado no console:
// Nome: José | Idade: 28
// Nome: Antonio | Idade: 22

Take: Retorna o número especificado de elementos de uma coleção e, em seguida, ignora os elementos restantes.

// Take: Retorna o número especificado de elementos
//       de uma coleção e, em seguida, ignora os 
//       elementos restantes.
var queryTake = Pessoas.Take(2);
foreach (Pessoa p in queryTake)
    Console.WriteLine(p.Nome);
// Resultado no console:
// José
// Antonio

Sum: Calcula a soma da seqüência de valores.

// Sum: Calcula a soma da seqüência de valores 
int sum = Pessoas.Sum(p => p.Idade);
Console.WriteLine("Somatório das Idades: {0}", sum.ToString());
// Resultado no console:
// Somatório das Idades: 134

SkipWhile: Ignora elementos de uma coleção até que a condição da expressão lambda seja verdadeira

// SkipWhile: Ignora elementos de uma coleção até que a condição da expressão lambda seja verdadeira
var querySkipWhile = Pessoas.SkipWhile(p => p.Idade != 20);
foreach (Pessoa p in querySkipWhile)
    Console.WriteLine("Nome: {0} | Idade: {1}", p.Nome, p.Idade.ToString());
// Resultado no console:
// Nome: Maria | Idade: 20
// Nome: Fernanda | Idade: 32
// Nome: João | Idade: 32

Skip: Ignora o número especificado de elementos em uma coleção e, em seguida, retorna os elementos restantes.

// Skip: Ignora o número especificado de elementos
//       em uma coleção e, em seguida, retorna os 
//       elementos restantes.
var querySkip = Pessoas.Skip(2);
foreach (Pessoa p in querySkip)
    Console.WriteLine(p.Nome);
// Resultado no console:
// Maria
// Fernanda
// João

SingleOrDefault: Retorna um único elemento de uma coleção ou o valor default caso nada satisfaça a condição. Ou, ainda, gera uma exceção se não há apenas um elemento que satisfaça a condição da expressão lambda.

// SingleOrDefault: Retorna um único elemento de uma coleção ou 
//                  o valor default caso nada satisfaça a condição.
//                  Ou, ainda,  gera uma exceção se não há apenas um 
//                  elemento que satisfaça a condição da expressão lambda.

// Exemplo 1: com erro, pois exitem 2 pessoas com 32 anos
try
{
    Pessoa pessoaSingleOrDefault1 = 
        Pessoas.SingleOrDefault(p => p.Idade == 32);
    Console.WriteLine(pessoaSingleOrDefault1.Nome);
}
catch (Exception ex)
{
    Console.WriteLine("Erro: {0}", ex.Message);
}
// Resultado no console:
// Erro: Sequence contains more than one matching element

// Exemplo 2: José é o único com 28 anos
Pessoa pessoaSingleOrDefault2 = Pessoas.SingleOrDefault(p => p.Idade == 28);
Console.WriteLine(pessoaSingleOrDefault2.Nome);
// Resultado no console:
// José        

// Exemplo 3: Retorno default
Pessoa pessoaSingleOrDefault3 = Pessoas.SingleOrDefault(p => p.Idade == 75);
if (pessoaSingleOrDefault3 == null)
    Console.WriteLine("Retorno default: NULL");
else
    Console.WriteLine(pessoaSingleOrDefault3.Nome);
// Resultado no console:
// Retorno default: NULL  

Single: Retorna um único elemento de uma coleção ou gera uma exceção se não houver apenas um elemento que satisfaça a condição da expressão lambda.

// Single: Retorna um único elemento de uma coleção ou 
//         gera uma exceção se não há apenas um elemento 
//         que satisfaça a condição da expressão lambda.

// Exemplo 1: com erro, pois exitem 2 pessoas com 32 anos
try
{
    Pessoa pessoaSingle1 = Pessoas.Single(p => p.Idade == 32);
    Console.WriteLine(pessoaSingle1.Nome);
}
catch (Exception ex)
{
    Console.WriteLine("Erro: {0}", ex.Message);
}
// Resultado no console:
// Erro: Sequence contains more than one matching element

// Exemplo 2: José é o único com 28 anos
Pessoa pessoaSingle2 = Pessoas.Single(p => p.Idade == 28);
Console.WriteLine(pessoaSingle2.Nome);
// Resultado no console:
// José

SequenceEqual: Determina quando duas coleções são idênticas.

// SequenceEqual: Determina quando duas coleções são idênticas.
bool bolSequenceEqual = Pessoas.SequenceEqual(OutrasPessoas);
if (bolSequenceEqual)
    Console.WriteLine("SequenceEqual: SIM.");
else
    Console.WriteLine("SequenceEqual: NÃO.");
// Resultado no console:
// SequenceEqual: NÃO

SelectMany: Projeta cada elemento de uma seqüência para um IEnumerable, resultando em uma única coleção.

// SelectMany: Projeta cada elemento de uma seqüência para um 
//             IEnumerable, resultando em uma única coleção.
var querySelectMany = Pessoas.SelectMany(p => p.Animais);
foreach (var animal in querySelectMany)
    Console.WriteLine("{0} - {1}", animal.Dono.Nome, animal.Nome);
// Resultado no console:
// José - Fred
// José - Billy
// Antonio - Pandora
// Antonio - Teny
// Antonio - Cindy
// Maria - Crodô
// Maria - Frodo

Select: seleciona apenas o valor mencionado, criando uma nova coleção com o mesmo tipo do valor selecionado.

// Select: seleciona apenas o valor mencionado, 
//         criando uma nova coleção com o mesmo 
//         tipo do valor selecionado
var querySelect = Pessoas.Select(p => p.Nome);
foreach (string nomePessoa in querySelect)
    Console.WriteLine(nomePessoa);
// Resultado no console:
// José
// Antonio
// Maria
// Fernanda
// João

Reverse: Ordena a coleção de forma reversa a forma atual

// Reverse: Ordena a coleção de forma reversa a forma atual
foreach (Pessoa p in Pessoas.Reverse())
    Console.WriteLine(p.Nome);
// Resultado no console:
// João
// Fernanda
// Maria
// Antonio
// José

Min: retorna o menor valor conforme a condição informada

// Min: retorna o menor valor conforme a condição informada 
int max = Pessoas.Min(p => p.Idade);
Console.WriteLine("Menor idade: {0}", max.ToString());
// Resultado no console:
// Menor idade: 20

Max: retorna o maior valor conforme a condição informada

// Max: retorna o maior valor conforme a condição informada 
int max = Pessoas.Max(p => p.Idade);
Console.WriteLine("Maior idade: {0}", max.ToString());
// Resultado no console:
// Maior idade: 32

LongCount: Determina a quantidade de elementos da coleção que satisfazem uma determinada condição.

// LongCount: Determina a quantidade de elementos da coleção 
//            que satisfazem uma determinada condição.
long qtTotal = Pessoas.LongCount();
Console.WriteLine("Quantidade Elementos: {0}", qtTotal.ToString());
long qtIdade32 = Pessoas.LongCount(p => p.Idade == 32);
Console.WriteLine("Idade - 32 anos: {0}", qtIdade32.ToString());
// Resultado no console:
// Idade - 32 anos: 2

LastOrDefault: Retorna o último elemento da coleção (com ou sem condição lambda), ou o valor default caso a condição não seja satisfeita.

// LastOrDefault: Retorna o último elemento da coleção 
//                (com ou sem condição lambda),
//                ou o valor default caso a condição não seja satisfeita.
Pessoa pessoaLastOrDefault = Pessoas.LastOrDefault(p => p.Idade == 32);
Console.WriteLine(pessoaLastOrDefault.Nome);
// Resultado no console:
// João

Last: Retorna o último elemento da coleção (com ou sem condição lambda).

// Last: Retorna o último elemento da coleção (com ou sem condição lambda).
Pessoa pessoaLast = Pessoas.Last(p => p.Idade >= 20);
Console.WriteLine(pessoaLast.Nome);
// Resultado no console:
// João