Use o código e tenha 10% de desconto!

Produtividade em C# Obtenha mais resultado com menos esforço

Cláudio Ralha

*Você terá acesso às futuras atualizações do livro.

Sobre o autor

Cláudio Ralha é cientista de dados, arquiteto de software, autor de vários livros e treinamentos, palestrante nas áreas de inteligência investigativa e desenvolvimento de software e apaixonado por compartilhar conhecimento.

Com 35 anos de experiência em informática e várias certificações Microsoft e IBM, o autor já atuou como colunista de informática do jornal O GLOBO (na época, tinha 18 anos de idade), editor técnico da revista Infomania, colaborador de revistas como CPU PC, CPU MSX, Geek, Hackers e PC Brasil, além de articulista em grandes portais como Macoratti.NET e Linha de Código.

Ao longo de sua carreira, Cláudio também ocupou cargos de gerente de desenvolvimento, analista desenvolvedor e administrador de banco de dados. Foi consultor de clientes como Petrobras, Shell, Esso, Furnas, Brascan, CVM, ONS, Organizações Globo, Rede Globo, Jornal O GLOBO, Brasil Veículos, Elsevier e SAAB Medav (Alemanha). Além disso, atuou em parceria com grandes consultorias como Accenture, Stefanini, IBM, ATT/PS, InforMaker, Relacional, Value Team, Softtek, Provider IT, CECAM e 3S Tecnologia.

Em 2003, fundou a Halteck Consulting onde permanece como CEO e instrutor. A empresa, com foco em consultoria, treinamentos e desenvolvimento de software, tem se destacado pelos serviços prestados, tanto em território nacional quanto no exterior, nas áreas de inteligência investigativa e desenvolvimento de software para as forças da lei, Exército Brasileiro e o setor privado.

Prefácio

Quando recebi o convite para escrever o prefácio deste livro, fiquei a princípio apreensivo pela responsabilidade, mas como conheço a obra do autor e o seu trabalho como profissional, também fiquei feliz com essa distinção e empolgado em apresentar o trabalho de um autor nacional sobre um tema atual que visa compartilhar conhecimento técnico sobre a principal linguagem da plataforma .NET.

Conheço o trabalho do Cláudio, que vem atuando há tempos na área de TI, uma boa parte com a plataforma .NET, e ele sempre se mostrou um profissional esmerado em seu trabalho e preocupado em estar em constante sintonia com a evolução que é inerente à nossa área de atuação.

Sou do tempo da internet discada e acompanho a evolução da linguagem C# desde o lançamento da versão 1.0 e sua crescente aceitação desde então. Com essa constante evolução e com o advento da .NET Core, um ambiente multiplataforma, a linguagem expandiu seus horizontes e suas possibilidades de atuação para fora do mundo Windows.

Isso com certeza acabou atraindo muitos desenvolvedores e desenvolvedoras para a plataforma .NET e a linguagem C# acabou se tornando a principal ferramenta de trabalho para codificação no ambiente .NET Core. Com toda essa responsabilidade, a linguagem precisa evoluir constantemente para incorporar novos recursos e assim poder continuar oferecendo um ambiente produtivo e robusto.

Nesse contexto, estar atualizado e conhecer os novos recursos da linguagem C# e do ambiente .NET Core pode fazer a diferença tanto no quesito desempenho quanto na produtividade. Embora possamos encontrar na internet muitos artigos relacionados ao assunto, nada como um bom livro para consultar e ler a qualquer momento. Por isso, sou um apreciador de livros com conteúdos técnicos relacionados a minha área de atuação, pois sei que mesmo após muitos anos de experiência na área sempre temos algo a aprender com outros profissionais e suas contribuições.

Ao lançar mais esta obra, na qual apresenta os recursos da linguagem C# de forma simples e objetiva, o autor nos brinda com um texto em português sobre um tema bem atual, abordando assuntos de interesse de toda a comunidade .NET. O livro serve para os que atuam profissionalmente na área, para aqueles que usam C# como um meio para alcançar seu objetivo e também para quem deseja migrar para essa linguagem.

Assim, este livro traz uma visão panorâmica atual da linguagem C#, comparando a evolução do código com exemplos práticos e pontuais, e, dessa forma, você não fica obrigado a uma leitura sequencial, podendo alternar entre os capítulos conforme o tópico de seu interesse no momento e usando a obra como um manual de consulta e referência para o dia a dia.

Bom estudo!

José Carlos Macoratti (Fundador do Portal Macoratti.NET)

Introdução

Alta produtividade é um objetivo perseguido por todo bom profissional em qualquer área. Quando se fala em desenvolvimento de software, especificamente, para alcançá-la não basta ter foco e esforço. Isso porque a todo momento surgem novas linguagens de programação que a cada release trazem novas funcionalidades, sem falar em uma infinidade de frameworks e bibliotecas. Infelizmente, mesmo que estudemos da hora de acordar até a hora de dormir todos os dias de nossas vidas, não seremos capazes de assimilar e principalmente colocar em prática, nos projetos em desenvolvimento, todas as opções fornecidas pelos fabricantes das tecnologias que utilizamos, pelo simples fato de que elas evoluem e são trocadas em uma velocidade insana.

Por outro lado, se pararmos para analisar com calma as principais linguagens de programação utilizadas no mercado de TI, veremos que a maior parte possui funcionalidades similares, como suporte a Orientação a Objetos, Generics, Inferência de tipos, Tipos anônimos, Expressões Regulares, Reflection, Programação Assíncrona, dentre outras.

Em termos práticos, o que faz toda a diferença é o fato de que algumas linguagens foram pensadas para serem mais concisas e legíveis que outras, características estas que aumentam substancialmente a nossa produtividade. Junte a uma delas uma IDE poderosa como o Visual Studio e um profissional que conhece bem suas ferramentas de trabalho e você terá a fórmula perfeita para se destacar no mercado e tocar seus projetos profissionais e pessoais na velocidade que almeja.

Criada há cerca de 22 anos, tendo como base linguagens como C++ e Java, a linguagem C# tem inovado a cada novo release e revolucionado a forma como se produz software. Ela é hoje a principal linguagem de desenvolvimento da Microsoft para as plataformas desktop, web e mobile e, com frequência, inclui funcionalidades que rapidamente caem no gosto dos desenvolvedores e depois são copiadas pelos concorrentes.

Ao longo deste livro 100% prático e recheado de exemplos curtos e simples, reunimos recursos suportados pelas versões mais recentes do compilador C# que, ao serem aplicados no código produzido, vão impactar positivamente no tamanho do código gerado e no tempo envolvido, resultando em alta produtividade.

Seguindo o mantra do “menos é mais”, você verá que existem novas formas de se resolver velhos problemas e que, só porque algo funciona, não significa que seja a melhor forma de concluir a tarefa. "Produtividade em C#" foca no que realmente importa para quem quer produzir um código elegante e de qualidade. Tenha em mente que o nosso código é o nosso melhor cartão de visitas e que é preciso se reinventar sempre. Venha conosco conhecer o que a linguagem C# tem de melhor a nos oferecer.

Bom estudo e sucesso em seus projetos!

Cláudio Ralha (Novembro de 2020)

Executando os projetos utilizando o .NET 5

A unificação dos frameworks .NET e .NET Core está se tornando uma realidade com a chegada do .NET 5. É uma mudança inevitável para a qual precisamos estar preparados e que nos brindará com vários recursos novos introduzidos no C# 9.0 e outros que já estão em desenvolvimento para o C# 10.0.

No momento em que a escrita deste livro foi finalizada (novembro de 2020), o novo framework havia acabado de ser lançado e para testar as novidades introduzidas na linguagem C# 9.0, ainda é necessário executar alguns passos que envolvem:

a) A atualização da sua cópia do Visual Studio através do instalador do Visual Studio. Note que não é mais necessário instalar o Visual Studio Preview, versão da IDE que contém recursos ainda não incluídos na versão de produção. A distribuição Community gratuita é suficiente para executar todos os exemplos deste livro.

b) A configuração da versão correta do .NET em uso após a criação de um projeto. Por enquanto, os projetos aparecem pré-configurados para o .NET 3.1 apesar de o .NET 5 já estar presente na lista de opções. Esses passos obviamente deixarão de ser necessários em futuras atualizações do Visual Studio.

Para criar uma aplicação de teste, execute os seguintes passos:

1. Execute o Visual Studio atualizado e crie um novo projeto do tipo Aplicação de Console (.NET Core) em C#. Atenção neste passo para não se confundir e escolher a opção Aplicação de Console (.NET Framework), que só permitirá escolher até o Framework .NET 4.8.

2. O projeto criado está configurado por padrão para usar o .NET Core 3.1 e o C# 8. Para configurá-lo para usar o .NET 5, clique com o botão direito do mouse sobre o arquivo do projeto no Gerenciador de Soluções e selecione Propriedades. A página de propriedades do projeto abrirá. Na guia Aplicativo, selecione em Estrutura de Destino a opção .NET 5.0 e a seguir tecle Ctrl + s para salvar a alteração.

Pronto! A partir de agora você já pode experimentar os novos recursos incluídos no compilador C# 9.0.

Boa parte dos exemplos deste livro podem ser reescritos usando os novos recursos. Não fizemos desta forma para que ele possa ser útil para o maior número de leitores e leitoras, mas você está livre para experimentar à vontade, pois não vamos criar nenhum projeto de teste que se alongue por vários capítulos. Todos os exemplos que apresentaremos são curtos e diretos. "Produtividade em C#" é uma obra que foca no que o time de desenvolvimento incluiu de útil e produtivo em todas as versões já lançadas do compilador e não em uma versão específica da linguagem.

Sumário

  • 1 Strings
    • 1.1 Criando strings mais legíveis
    • 1.2 Convertendo strings
    • 1.3 Formatando strings
    • 1.4 Sorteando uma string de um array ou lista
    • 1.5 Gerando uma string randômica
    • 1.6 Utilizando comentários especiais para sinalizar o código
    • 1.7 Utilizando expressões regulares para validar dados
  • 2 Operadores
    • 2.1 Usando os operadores de incremento ++ e de decremento --
    • 2.2 Usando os operadores especiais de atribuição
    • 2.3 Usando o operador condicional nulo ?
    • 2.4 Usando o operador de coalescência nula ??
    • 2.5 Usando o operador ternário ?:
    • 2.6 Usando o operador lógico is not
    • 2.7 Empregando a sobrecarga de operadores
  • 3 Estruturas condicionais e de repetição
    • 3.1 Criando estruturas condicionais e de repetição usando code snippets
    • 3.2 Utilizando laços for
    • 3.3 Utilizando laços while e do while
    • 3.4 Utilizando laços foreach
    • 3.5 Utilizando estruturas switch
    • 3.6 Empregando correspondência de padrões
    • 3.7 Melhorias na correspondência de padrões do C# 9.0
    • 3.8 Compactando instruções switch usando expressões switch
  • 4 Tipos e membros
    • 4.1 Criando tipos e membros usando code snippets
    • 4.2 Utilizando a sintaxe simplificada em tipos anuláveis
    • 4.3 Utilizando literais binárias e separadores de dígitos
    • 4.4 Criando múltiplos construtores de instância para uma classe
    • 4.5 Declarando uma propriedade autoimplementada como somente leitura ou somente escrita
    • 4.6 Iterando sobre um enumerado
    • 4.7 Utilizando inicializadores de objetos e de coleções
    • 4.8 Utilizando parâmetros opcionais e parâmetros nomeados
    • 4.9 Utilizando métodos de extensão para estender uma classe
    • 4.10 Utilizando o tipo dynamic para retornar objetos diferentes
    • 4.11 Utilizando yield em vez de criar coleções temporárias
    • 4.12 Utilizando declarações using para sinalizar objetos descartáveis
    • 4.13 Utilizando métodos de interface padrão
    • 4.14 Inicializando objetos usando new expressions
    • 4.15 Utilizando registros para criar tipos de referência imutáveis
  • 5 Tuplas
    • 5.1 Retornando múltiplos valores de um método usando uma tupla
    • 5.2 Passando múltiplos valores para um método usando tuplas
    • 5.3 Desconstruindo os elementos de uma tupla
    • 5.4 Desconstruindo os elementos de uma classe
    • 5.5 Descartando retornos de métodos e parâmetros out
  • 6 Generics
    • 6.1 Criando tipos genéricos
    • 6.2 Utilizando constraints em tipos genéricos
    • 6.3 Utilizando constraints em métodos genéricos
    • 6.4 Driblando limitações de cálculos em métodos genéricos
    • 6.5 Criando interfaces genéricas
    • 6.6 Utilizando tipos genéricos existentes no framework
  • 7 LINQ
    • 7.1 Filtrando dados usando LINQ
    • 7.2 Empregando operadores de elementos com retorno único
    • 7.3 Empregando Distinct para obter resultados únicos
    • 7.4 Empregando Union para combinar duas fontes de dados
    • 7.5 Empregando diferentes tipos de junções
    • 7.6 Ordenando o resultado das consultas
  • 8 Exceções
    • 8.1 Criando blocos de tratamento de exceções usando code snippets
    • 8.2 Tratando exceções usando filtros de exceções
    • 8.3 Efetuando log de erros usando filtros de exceções
    • 8.4 Inspecionando a pilha de chamadas
    • 8.5 Preservando a pilha de chamadas
    • 8.6 Utilizando throw em contextos que requerem uma expressão
    • 8.7 Utilizando o operador await em blocos catch e finally
    • 8.8 Interrompendo a execução quando uma exceção for gerada
    • 8.9 Capturando exceções do próprio framework e de bibliotecas de terceiros
    • 8.10 Consultando a pseudovariável $exception
    • 8.11 Criando classes de exceção personalizadas
  • 9 Geração de código
    • 9.1 Gerando classes a partir de JSON e XML
    • 9.2 Gerando classes e structs a partir do seu uso
    • 9.3 Gerando propriedades e campos a partir do seu uso
    • 9.4 Gerando métodos a partir do seu uso
    • 9.5 Gerando construtores a partir do seu uso
    • 9.6 Gerando enumerados a partir do seu uso
    • 9.7 Usando snippets de código em seus projetos
    • 9.8 Criando os seus próprios snippets de código
    • 9.9 Documentando o código-fonte com comentários XML
    • 9.10 Baixando templates de projeto do Visual Studio Marketplace
    • 9.11 Criando os seus próprios templates de projeto
  • 10 Limpeza de código-fonte
    • 10.1 Entendendo analisadores, correções de código e refatorações
    • 10.2 Impondo regras de estilo de código aos projetos
    • 10.3 Executando limpeza de código
    • 10.4 Visualizando os resultados das métricas de código
    • 10.5 Instalando extensões de inspeção de código e refatoração
  • 11 Ações rápidas e refatoração
    • 11.1 Dividindo o código de uma classe extensa em múltiplos arquivos
    • 11.2 Convertendo um tipo anônimo em uma classe
    • 11.3 Promovendo um membro de uma classe a uma interface ou tipo base
    • 11.4 Convertendo campos em propriedades
    • 11.5 Promovendo funções locais a métodos
    • 11.6 Reordenando os parâmetros de um método
    • 11.7 Adicionando nomes de argumentos
    • 11.8 Adicionando checagem de nulos para parâmetros
    • 11.9 Usando o comando de extração de método
    • 11.10 Convertendo string.Format em string interpolada
    • 11.11 Convertendo um loop for em um loop foreach
    • 11.12 Convertendo um loop foreach em um loop for
    • 11.13 Convertendo um loop foreach em LINQ ou expressões lambda
    • 11.14 Convertendo estruturas condicionais if em switch
    • 11.15 Adicionando cláusulas case ausentes em um switch
    • 11.16 Utilizando inicializadores de objetos
    • 11.17 Utilizando inicializadores de coleções
  • 12 Depuração
    • 12.1 Forçando o modo de interrupção do depurador
    • 12.2 Definindo pontos de interrupção no seu código
    • 12.3 Utilizando pontos de interrupção condicionais
    • 12.4 Utilizando pontos de interrupção de dados
    • 12.5 Utilizando pontos de interrupção de função
    • 12.6 Enviando informações para a janela de saída usando tracepoints
    • 12.7 Navegando pelo código em modo de interrupção
    • 12.8 Visualizando os dados durante a depuração
    • 12.9 Explorando DataTips
  • 13 Atributos de depuração
    • 13.1 Empregando os atributos de depuração StepThrough, Hidden e NonUserCode
    • 13.2 Controlando a exibição com o atributo de depuração Display
    • 13.3 Definindo o que será exibido com o atributo de depuração Browsable
    • 13.4 Melhorando a visualização dos dados durante a depuração com o atributo de depuração TypeProxy
  • 14 Compilação condicional
    • 14.1 Utilizando definições de símbolos e diretivas de pré-processador condicional
    • 14.2 Utilizando as diretivas de diagnóstico #error e #warning
    • 14.3 Utilizando a constante DEBUG
    • 14.4 Empregando blocos de código para versões específicas do Framework
    • 14.5 Usando o atributo Conditional em um método
    • 14.6 Ativando o suporte a tipos de referência anuláveis
    • 14.7 Agrupando os membros das classes em regiões
  • 15 Referências

Dados do produto

Número de páginas:
461
ISBN:
978-65-86110-70-8
Data publicação:
05/2021

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter

*Você terá acesso às futuras atualizações do livro.