C#: Dos Fundamentos às Técnicas Avançadas – Um CheatSheet para Iniciantes

A abrangente C# Cheat Sheet foi projetada para ajudar os desenvolvedores a dominar a sintaxe e os principais conceitos relacionados à programação C#. Conteúdo Estrutura básica Tipos de dados Variáveis Constantes Declarações Condicionais rotações Matrizes Listas Dicionários Métodos Classes e objetos Manipulação de exceção Delegados, Eventos e Lambdas LINQ (consulta integrada à linguagem) Atributos Assíncrono/Aguardar Diversos Manipulação de cordas E/S de arquivo Data hora Genéricos Anuláveis Atributos e Reflexão Métodos de extensão Injeção de dependência Aulas Parciais Interoperabilidade Tipos anônimos Tuplas Correspondência de padrões Funções locais Registros com Expressões Indexadores e intervalos usando declaração Tipos de referência anuláveis (NRTs) Uso baseado em padrão Padrões de propriedade Implementações de interface padrão Vinculação Dinâmica 1. Estrutura Básica Todos os programas C# seguem uma estrutura fundamental, descrita abaixo: using System; public class HelloWorld { public static void Main(string[] args) { Console.WriteLine("Hello, World!"); } } A partir do .NET 5, as instruções de nível superior simplificam o conteúdo do Program.cs: Console.WriteLine("Hello, World"); 2. Tipos de dados C# oferece suporte a vários tipos de dados, como: Tipos de valor: int, char e float Tipos de referência: string, classe e array 3. Variáveis Variáveis são nomes simbólicos para valores: int age = 30; // integer variable string name = "John"; // string variable double PI = 3.14159; // double for floating-point numbers bool isLoggedIn = true; // boolean variable Use 'var' para inferência de tipo: var number = 5; // compiler infers type as int var message = "This is a message"; // compiler infers type as string 4. Constantes Constantes contêm valores imutáveis: const double GRAVITY = 9.81; // constant for gravitational acceleration const string COMPANY_NAME = "MyCompany"; // constant company name 5. Declarações Condicionais Controle o fluxo do programa com base nas condições: int age = 20; if (age >= 18) { Console.WriteLine("You are eligible to vote."); } else { Console.WriteLine("You are not eligible to vote."); } switch (variable) { /*...*/ } // Switch statement 6. Laços Execute o código repetidamente: for (int i = 1; i <= 5; i++) { Console.WriteLine(i); } foreach (var item in collection) { /*...*/ } // Foreach loop while (condition) { /*...*/ } // While loop do { /*...*/ } while (condition); // Do-while loop 7. Matrizes Coleções de elementos de tamanho fixo: string[] names = new string[3] { "Alice", "Bob", "Charlie" }; Console.WriteLine(names[1]); // Output: Bob (accessing element at index 1) 8. Listas Coleções dinâmicas semelhantes a arrays: List numbers = new List (); numbers.Add(1); numbers.Add(2); numbers.Add(3); foreach (var number in numbers) { Console.WriteLine(number); } 9. Dicionários Pares de valores-chave para associação de dados: Dictionary phonebook = new Dictionary (); phonebook.Add("John Doe", "123-456-7890"); phonebook.Add("Jane Doe", "987-654-3210"); Console.WriteLine(phonebook["John Doe"]); // Output: 123-456-7890 10. Métodos Encapsular lógica reutilizável: public class Rectangle { public double Width { get; set; } public double Height { get; set; } public double GetArea() { return Width * Height; } } public class Program { public static void Main(string[] args) { Rectangle rect = new Rectangle(); rect.Width = 5; rect.Height = 10; double area = rect.GetArea(); Console.WriteLine($"Area of rectangle: {area}"); } } 11. Classes e objetos As classes definem projetos para objetos: public class MyClass // Class definition { public string PropertyName { get; set; } // Properties store data public void MethodName() { /*...*/ } // Methods define actions } MyClass obj = new MyClass(); // Object creation 12. Tratamento de exceções Gerencie erros de tempo de execução normalmente: public static int GetNumberInput() { while (true) { try { Console.WriteLine("Enter a number: "); string input = Console.ReadLine(); return int.Parse(input); } catch (FormatException) { Console.WriteLine("Invalid input. Please enter a number."); } } } public static void Main(string[] args) { int number = GetNumberInput(); Console.WriteLine($"You entered: {number}"); } 13. Delegados, Eventos e Lambda Para programação orientada a eventos e manipulação de métodos: public delegate void MyDelegate(); // Delegate declaration event MyDelegate MyEvent; // Event declaration public class Person { public string Name { get; set; } public int Age { get; set; } } public static void Main(string[] args) { List people = new List () { new Person { Name = "Alice", Age = 30 }, new Person { Name = "Bob", Age = 25 }, new Person { Name = "Charlie", Age = 40 }, }; people.Sort((p1, p2) => p1.Name.CompareTo(p2.Name)); foreach (var person in people) { Console.WriteLine(person.Name); // Output: Alice, Bob, Charlie (sorted by name) } } 14. LINQ (consulta integrada à linguagem) Capacidades de consulta para manipulação de dados: using System.Linq; public static void Main(string[] args) { List numbers = new List () { 1, 2, 3, 4, 5, 6 }; var evenNumbers = numbers.Where(x => x % 2 == 0); foreach (var number in evenNumbers) { Console.WriteLine(number); // Output: 2, 4, 6 } } 15. Atributos Adicione metadados aos elementos de código: [Obsolete("Use the new DoSomethingV2 method instead.")] public void DoSomething() { // Implementation here } public void DoSomethingV2() { // New and improved implementation } 16. Assíncrono/Aguarda Para execução de código sem bloqueio: using System.Threading.Tasks; public static async Task DownloadFileAsync(string url, string filePath) { // Simulate downloading data asynchronously await Task.Delay(2000); // Simulate a 2-second download // Write downloaded data to the file File.WriteAllText(filePath, "Downloaded content"); Console.WriteLine($"File downloaded to: {filePath}"); } public static void Main(string[] args) { string url = "https://example.com/data.txt"; string filePath = "downloaded_data.txt"; DownloadFileAsync(url, filePath); // Continue program execution while download happens in the background Console.WriteLine("Downloading file..."); Console.WriteLine("Meanwhile, you can do other things..."); } 17. Diversos Recursos adicionais de idioma: enum, interface, classe, registro e estrutura dinâmico, é, como, var e nameof 18. Manipulação de Cordas Métodos poderosos de manipulação de strings: string.Concat(); // Combine strings string.Join(); // Join elements str.Split(); // Split string str.ToUpper(); // Convert to uppercase str.ToLower(); // Convert to lowercase 19. E/S de arquivo Operações com arquivos: using System.IO; // Required for File I/O File.ReadAllText(path); // Read file content File.WriteAllText(path, content); // Write to file File.Exists(path); // Check file existence 20. Data e hora Manipulação de data e hora: using System; public static void Main(string[] args) { DateTime startDate = DateTime.Parse("2024-03-10"); DateTime endDate = DateTime.Now; TimeSpan difference = endDate - startDate; Console.WriteLine($"Time difference: {difference.Days} days, {difference.Hours} hours"); } 21. Genéricos Estruturas de dados com segurança de tipo: public class Stack { private List items = new List (); public void Push(T item) { items.Add(item); } public T Pop() { T item = items[items.Count - 1]; items.RemoveAt(items.Count - 1); return item; } } public static void Main(string[] args) { Stack messages = new Stack (); messages.Push("Hello"); messages.Push("World"); string message = messages.Pop(); Console.WriteLine(message); // Output: World } 22. Anuláveis Permitir que os tipos de valor sejam nulos: int? nullableInt = null; // Nullable integer 23. Atributos e Reflexão Metadados e introspecção de tipo: public class Person { public string Name { get; set; } public int Age { get; set; } } public static void Main(string[] args) { Type personType = typeof(Person); PropertyInfo[] properties = personType.GetProperties(); foreach (PropertyInfo property in properties) { Console.WriteLine(property.Name); // Output: Name, Age } } 24. Métodos de extensão Adicione métodos aos tipos existentes: public static class StringExtensions { public static string ToUppercase(this string str) { return str.ToUpper(); } } public static void Main(string[] args) { string message = "Hello, world!"; string uppercased = message.ToUppercase(); // Using the extension method Console.WriteLine(uppercased); // Output: HELLO, WORLD! } 25. Injeção de Dependência Design de código fracamente acoplado: public interface ILogger { void LogMessage(string message); } public class MyService { private readonly ILogger _logger; public MyService(ILogger logger) { _logger = logger; } public void DoSomething() { _logger.LogMessage("Doing something..."); } } // Implementing the ILogger interface (example) public class ConsoleLogger : ILogger { public void LogMessage(string message) { Console.WriteLine(message); } } public static void Main(string[] args) { ILogger logger = new ConsoleLogger(); MyService service = new MyService(logger); service.DoSomething(); } 26. Aulas Parciais Dividindo uma única definição de classe: public partial class MyClass { /*...*/ } // Partial class definition 27. Interoperabilidade Interoperabilidade com outras linguagens: using System; using System.Runtime.InteropServices; [DllImport("user32.dll")] public static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType); public static void Main(string[] args) { MessageBox(IntPtr.Zero, "Hello from C#!", "Interop Example", 0); } 28. Tipos anônimos Criando tipos sem nome: código csharpCopy var person = new { Name = "John", Age = 30 }; Console.WriteLine($"Name: {person.Name}, Age: {person.Age}"); 29. Tupla Estruturas de dados com um número específico de elementos: (string Name, int Age) person = ("Alice", 30); Console.WriteLine($"Name: {person.Name}, Age: {person.Age}"); // Accessing elements using Item1 and Item2 30. Correspondência de padrões Simplifica certas tarefas de programação: object obj = new Person { Name = "Bob", Age = 25 }; if (obj is Person { Name: "Bob", Age >= 18 }) { Console.WriteLine("Bob is an adult."); } 31. Funções locais Encapsule a lógica dentro dos métodos: public static int Calculate(int number) { int Factorial(int n) { if (n == 0) return 1; return n * Factorial(n - 1); } return Factorial(number); } public static void Main(string[] args) { int result = Calculate(5); Console.WriteLine($"5! = {result}"); } 32. Registros Sintaxe concisa para tipos de referência: public record Person(string Name, int Age); public static void Main(string[] args) { Person person1 = new Person("Alice", 30); Person person2 = new Person("Alice", 30); // Records provide default equality comparison if (person1 == person2) { Console.WriteLine("People are equal"); } } 33. com Expressões Mutação não destrutiva para registros: var john = new Person("John", 30); var jane = john with { Name = "Jane" }; // Non-destructive mutation 34. Indexadores e intervalos Acesso flexível aos dados: int[] arr = {0, 1, 2, 3, 4, 5}; var subset = arr[1..^1]; // Indexer and range usage 35. usando Declaração Descarte objetos IDisposable: using var reader = new StreamReader("file.txt"); // using declaration 36. Tipos de referência anuláveis (NRTs) Evite exceções de referência nula: public class Person { public string Name { get; set; } public int Age { get; set; } } public static void Main(string[] args) { Person person = new Person() { Age = 30 }; // NRTs require null checks before accessing properties if (person?.Name != null) { Console.WriteLine(person.Name); } else { Console.WriteLine("Name is null"); } } 37. Uso baseado em padrões Mais padrões na instrução using: public ref struct ResourceWrapper { /*...*/ } // Resource wrapper using var resource = new ResourceWrapper(); // Pattern-based using 38. Padrões de propriedade Desconstrua objetos na correspondência de padrões: if (obj is Person { Name: "John", Age: var age }) { /*...*/ } // Property pattern matching 39. Implementações de interface padrão Interfaces com implementações de métodos padrão: public interface IPerson { /*...*/ } // Interface with default method public class MyClass : IPerson { /*...*/ } // Class implementing interface 40. Vinculação Dinâmica Resolução do tipo de tempo de execução: dynamic d = 5; // Dynamic binding d = "Hello"; // No compile-time type checking Conclusão Esta folha de dicas estruturada de C# termina com tópicos e técnicas avançadas, fornecendo uma referência abrangente para desenvolvedores que desejam aprimorar suas habilidades de programação em C#. Para exemplos detalhados e exploração adicional, consulte as seções específicas descritas neste guia. Boa codificação! Programação C#🚀 Obrigado por fazer parte da comunidade C#! Antes que partas: Se você chegou até aqui, mostre seu agradecimento com palmas e siga o autor! 👏️️ Siga-nos: | | | | | X LinkedIn Dev.to Hashnode Boletim informativo Tumblr Visite nossas outras plataformas: | | | | GitHub Instagram TikTok Quora Diariamente.dev Inspirado por: https://zerotomastery.io/cheatsheets/csharp-cheat-sheet/#constants Também publicado aqui