[Base64String()]
public string AccessToken { get; set; }

[AllowedValues(1,2,8,23,55)]
public uint Age { get; set; }

[DeniedValues(1,2,3,4,5)]
public string Age { get; set; }

[Length(7,25)]
public string Name { get; set; }

[Required(DisallowAllDefaultValues = true)]
public Guid Id{ get; set; }

É um operador abreviado usado para retornar o operando esquerdo se não for nulo e o operando direito se o operando esquerdo for nulo. Esse operador é útil quando você precisa fornecer um valor padrão se uma variável for nula.

string name = null;

string result = name ?? "Unknown";

Console.WriteLine(result); // Output: Unknown

2 — Conditional Operator (?:)

É usado para avaliar uma condição e retornar um valor se a condição for verdadeira e outro valor se a condição for falsa. Esse operador é útil quando você precisa fornecer um valor padrão com base em uma condição.

string name = null;

string result = (name != null) ? name : "Unknown";

Console.WriteLine(result); // Output: Unknown

3 — 𝗡𝘂𝗹𝗹 𝗖𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗢𝗽𝗲𝗿𝗮𝘁𝗼𝗿 (?.)

É usado para acessar membros de um objeto se o objeto não for nulo, caso contrário, retornará nulo. Este operador é útil quando você precisa acessar propriedades ou métodos de um objeto que pode ser nulo

string name = null;

int? length = name?.Length;

Console.WriteLine(length); // Output: null

4 — 𝗡𝘂𝗹𝗹 𝗖𝗼𝗮𝗹𝗲𝘀𝗰𝗶𝗻𝗴 𝗔𝘀𝘀𝗶𝗴𝗻𝗺𝗲𝗻𝘁 𝗢𝗽𝗲𝗿𝗮𝘁𝗼𝗿 (??=)

É usado para atribuir o operando à direita ao operando à esquerda se o operando à esquerda for nulo. Este operador é útil para atribuir um valor padrão a uma variável se ela estiver nula no momento. Pode simplificar o código e torná-lo mais conciso.

Antes:

string fullName = null;

if (fullName is null)
{
    fullName = "No name found";
}

Depois:

string name= null;

name??= "Unknown";

Console.WriteLine(name); // Output: Unknown

5 — Null-Forgiving Operator (!.)

É usado para informar ao compilador que um valor não é nulo, mesmo que o compilador não consiga determinar que o valor não é nulo. Esse operador é útil quando você sabe que um valor não será nulo, mas o compilador não consegue determinar que não será nulo.

string name = null!;

int length = name.Length;

Console.WriteLine(length); // Output: System.NullReferenceException

Middleware é um software montado em um pipeline de aplicativo para lidar com solicitação e resposta.
Em palavras simples, o middleware nos dá a facilidade de adicionar lógica adicional antes e depois da solicitação HTTP.

Como middleware funciona?

Suponha que tenhamos três middlewares em nosso aplicativo e, para cada middleware, inserimos duas vezes.

• A primeira lógica do middleware é executada e então a enviamos para o próximo middleware
• Em segundo lugar, quando a solicitação voltar após a execução dos próximos middlewares

Multiplas formas de criar middlewares

Temos três maneiras de criar middleware no .NET Core

• Request delegate
• Convention
• Middleware factory

Criando middleware usando Request Delegate

Desta forma, podemos criar middleware usando direto em nosso Program.cs
Podemos adicionar nossa lógica que queremos executar antes ou depois desse middleware.
Se você não quiser chamar o próximo middleware, podemos fazer isso não invocando o próximo.
Nosso arquivo Program.cs ficaria assim:

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.Use(async (context, next) =>
{
    Console.WriteLine("Before");

    await next.Invoke();

    Console.WriteLine("After");
});

app.Run();

Criando middleware by Convention

• Crie uma classe do seu middleware e passe RequestDelegate no seu construtor.
• Agora adicione a responsabilidade do método para a lógica antes e depis do middleware, passe o HttpContext
• Adicione o middleware no arquivo Program.cs

Depois dos primeiros dois passos, nosso código irá ficar assim:

public class ConventionMiddleware
{
    private readonly RequestDelegate _next;

    public ConventionMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext context)
    {
        Console.WriteLine("Before");

        await next.Invoke();

        Console.WriteLine("After");
    }
}

Adicione no arquivo Program.cs o middleware da seguinte forma:
app.UseMiddleware<name>()

app.UseMiddleware<ConventionMiddleware>();

Criando middleware usando Factory

Esta é uma versão modificada da forma convencional, neste caso nós criamos uma classe e herdamos deIMiddleware. Neste caso IMiddleware obriga-nos a implementar o métodoInvokeAsync. Então o código fica assim:

public class FactoryMiddleware: IMiddleware
{
    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        Console.WriteLine("Before");

        await next.Invoke();

        Console.WriteLine("After");
    }
}

Nessa última etapa é adicionar o middleware no arquivoProgram.cs, mas dessa vez nós não podemos fazer isso utilizando app.UseMiddleware, nós temos que adicionar no container DI integrado. Nós temos que registrar o serviço da seguinte forma:

builder.Services.AddTransient<FactoryMiddleware>();

app.UseMiddleware<FactoryMiddleware>();

O Factory Method é mais apreciado pelos desenvolvedores porque tem menos chance de erro e é mais limpo.

No livro, o autor nos mostra 8 ensinamentos sobre finanças, com pontos de vistas duas pessoas com visões bem distintas sobre enriquecimento.

1 — As classes média e baixa trabalham por dinheiro. Os ricos fazem com que o dinheiro trabalhe para eles.

Trabalhar bastante por dinheiro, pensando que comprará aquilo que acha que lhe trará felicidade, é também uma forma horrível de viver, assim como passar uma vida determinada pelo valor em seu contracheque ou no saldo da sua conta bancária também é terrível.

As pessoas trabalham, recebem seu salário e gastam. Mesmo que uma pessoa receba uma promoção ou encontre um emprego melhor, essa situação não melhora. Isso porque, quanto mais as pessoas ganham, mais elas tendem a gastar. Portanto, a ideia é que você saia desse ciclo e pare de gastar o seu salário com coisas que não importam.

Sair desse ciclo, parar de gastar seu salário com o que não importa e não tentar ter um padrão de vida mais caro são os primeiros passos rumo a abundância financeira.

Um emprego é apenas uma solução de curto prazo para um problema de longo prazo.

2 — Há uma diferença entre ser pobre e estar quebrado. Estar quebrado é algo temporário, ser pobre é algo eterno.

É importantíssimo saber a diferença entre um ativo e um passivo, e só adquirir ativos. Isso é tudo que precisamos saber.

No início da nossa vida isso pode parecer longe da realidade, mas é possível iniciar cedo e ter uma vida confortável. Um luxo verdadeiro é uma recompensa por ter investido e desenvolvido uma coluna de ativos consistente.

Ativos: É tudo aquilo que você possa adquirir ou construir e que lhe garanta rendimentos, que lhe gere renda. Um ativo possibilita a entrada de dinheiro em seu fluxo de caixa e acelera o crescimento financeiro.

• Negócios que não exijam a minha presença. Se tiver que trabalhar neles, não é um negócio, é uma profissão
• Ações
• Títulos
• Imóveis que geram renda
• Promissórias
• Royalties de propriedade intelectual, com música, literatura e patentes
• Tudo o que tenha valor, gere renda ou se valorize e tenho um mercado líquido

Passivos: É tudo aquilo que quando adquirido ou construído gera despesas, gastos periódicos e constantes, os passivos contribuem negativamente no fluxo de caixa, pois reduzem o seu saldo do mesmo.

• Financiamentos
• Empréstimos
• Cartão de crédito

3 — Cuide do seu negócio

Comece a cuidar do seu negócio. Mantenha o seu emprego, mas comece a comprar ativos reais e não passivos, reduzindo também as despesas e passivos.

4 — A história dos impostos e o poder das sociedades anônimas

Muitas pessoas veem Robin Hood como um herói, tirando dos ricos para dar aos pobres. Mas ele está mais pra um trapaceiro.

Embora o sentimento popular seja de que os ricos deveriam pagar mais impostos e doar aos pobres, na realidade, a classe média que é altamente tributada, especialmente a parcela instruída e de alta renda.

A medida que o governo se expande, aumenta a quantidade necessária de dinheiro advindo de impostos para sustentá-lo.

Uma sociedade anônima é apenas um documento que cria uma instituição legal. Não é algo material, uma fábrica ou um grupo de pessoas. Mas ela permite uma taxa de imposto de renda mais baixa do que os indivíduos teriam, e certas despesas podem ser pagas pela corporação com o lucro antes do pagamento dos impostos.

Na Inglaterra e nos Estados Unidos, originalmente não havia impostos, apenas contribuições temporárias ocasionais para arcar com situações como a guerra.

Em 1874, a Inglaterra tornou o imposto de renda permanente para seus cidadãos. Nos Estados Unidos, a adoção ocorreu em 1913.

Quanto mais você se dedica ao seu trabalho formal, mais pagará imposto ao governo. Os impostos punem as mesmas pessoas que votaram por eles.

Empresários de Sociedades Anônimas

• Ganham
• Gastam
• Pagam impostos

Trabalhadores de Sociedades Anônimas

• Ganham
• Pagam impostos
• Gastam

5 — Os Ricos Inventam O Dinheiro

Muitas vezes, no mundo real, não são os espertos que tomam a dianteira, mas os ousados.

Todos temos um potencial tremendo e fomos abençoados com dons. Contudo, a única coisa que nos detém é a insegurança. Não é tanto a falta de informação, mas sim a de autoconfiança. Alguns são mais afetados do que outros.

O ativo mais poderoso que temos é a nossa mente. Se bem treinada, cria uma riqueza sem precedentes.

A inteligência financeira é constuída por essas quatro habilidades técnicas:

• Contabilidade: é a proficiência financeira ou a habilidade de ler os números. Esta é uma habilidade vial se quiser construir negócios ou investir.
• Investimento: é a ciência do dinheiro que faz dinheiro
• Entendimento de mercado: a ciência da oferta e da procura. Graham Bell deu ao mercado o que este desejava, assim como Bill Gates e Steve Jobs. Uma casa de R$ 75 mil oferecida a R$ 60 mil e que custou R$ 20 mil também foi o resultado de perceber uma oportunidade criada pelo mercado. Alguém estava comprando e alguém, vendendo.
• A lei: o conhecimento de lei e regulamentos estaduais e nacionais sobre contabilidade e empresas. Recomenda-se jogar dentro das regras.

Os problemas com os investimento “seguros” é que muitas vezes são herméticos, ou seja, tão seguros que os ganhos são reduzidos.
Se souber o que está fazendo, você não está jogando. Jogo é quando você põe dinheiro em um negócio e reza para que dê certo.
As grandes oportunidades não são vista com seus olhos. Mas com sua mente.

• Encontre oportunidades que os outros deixam passar
• Levante dinheiro
• Reúna pessoas espertas

6 — Trabalhe para aprender — não por dinheiro

Se aprendermos e dominarmos apenas mais uma habilidade, a nossa renda se multiplicará exponencialmente. Quando se trata de dinheiro, a única habilidade que a maioria das pessoas conhece é trabalhar arduamente.

É importante quando se é novo trabalhar e experiementar diversos tipos de trabalhos, isso irá gerar experiência e conhecimentos que poucas irão ter mais a frente. Diversificar é crescer.

O objetivo é procurar um trabalho que ensine as habilidades que precisam, por mais que não goste do local ou do cargo, irá ser um aprendizado e estará recebendo para isso.

7 — Supere os obstáculos

Existem algumas razões pelas quais as pessoas financeiramente proficientes não desenvolvem seu fluxo de caixa, e é necessário superar essas razões como:

• Medo
• Ceticismo
• Preguiça
• Maus hábitos
• Arrogância

8 — Movimente-se

O ouro está por toda parte. A maioria das pessoas não foi treinada para vê-lo.

• Ache um motivo além da realidade: o poder do espírito
• Faça escolhas diárias: o poder da decisão
• Selecione amigos com cuidado: o poder da associação
• Domine uma fórmula e, então, aprenda uma nova: o poder do aprendizado rápido
• Pague a si mesmo em primeiro lugar: o poder do autocontrole e da disciplina
• Pague bem seus concorrentes: o poder do bom conselho
• Seja um “doador inteligente”: o poder do retorno
• Use ativos para comprar supérfluos: o poder do foco
• Escolha os heróis: o poder dos mitos
• Ensine e receberá: o poder da doação

1. S — Single Responsiblity Principle (Princípio da Responsabilidade Única)
2. O — Open-Closed Principle (Princípio Aberto-Fechado)
3. L — Liskov Substitution Principle (Princípio da Substituição de Liskov)
4. I — Interface Segregation Principle (Princípio da Segregação da Interface)
5. D — Dependency Inversion Principle (Princípio da Inversão da Dependência)

Esses princípios ajudam os desenvolvedores a escreverem códigos mais limpos, separando responsabilidades, diminuindo acoplamentos, facilitando na refatoração e estimulando o reaproveitamento do código.

1. SRP — Single Responsibility Principle:

Princípio da Responsabilidade Única — Uma classe deve ter um, e somente um, motivo para mudar.

Esse princípio declara que uma classe deve ser especializada em um único assunto e possuir apenas uma responsabilidade dentro do software, ou seja, a classe deve ter uma única tarefa ou ação para executar.

O princípio da responsabilidade única não se limita somente a classes, ele também pode ser aplicado em métodos e funções, ou seja, tudo que é responsável por executar uma ação, deve ser responsável por apenas aquilo que se propõe a fazer.

Antes:

public class User
{
    public bool LogIn(string userName, string password) {...}
    public bool SignUp(UserDTO user) {...}
    public bool SendEmail(SendEmailDTO sendEmail) {...}
    public void LogInformation(string message) {...}
}

Depois:

public class User
{
    public bool LogIn(string userName, string password) {...}
    public bool SignUp(UserDTO user) {...}
}

public class EmailService
{
    public bool SendEmail(SendEmailDTO sendEmail) {...}
}

public class LoggingService
{
    public void LogInformation(string message) {...}
}

2. OCP — Open-Closed Principle:

Princípio Aberto-Fechado — Objetos ou entidades devem estar abertos para extensão, mas fechados para modificação, ou seja, quando novos comportamentos e recursos precisam ser adicionados no software, devemos estender e não alterar o código fonte original.

Separe o comportamento extensível por trás de uma interface e inverta as dependências.
Uncle Bob

Antes:

No primeiro código temos apenas um tipo de empregado, o Contract. Quando surgir a necessidade de outro tipo, adicionaríamos mais uma condição, no nosso caso o Permanent

public class BasicSalaryCalculator
{
    public decimal GetBasicSalary(EmployeeType employeeType)
    {
        decimal basicSalary = 0;

        if (employeeType == EmployeeType.Contract) {...}

        return basicSalary;
    }
}

public class BasicSalaryCalculator
{
    public decimal GetBasicSalary(EmployeeType employeeType)
    {
        decimal basicSalary = 0;

        if (employeeType == EmployeeType.Contract) {...}
        else if (employeeType == EmployeeType.Permanent) {...}

        return basicSalary;
    }
}

Depois:

Single Responsability

public abstract class BasicSalary
{
    public abstract double GetBasicSalary(EmployeeType employeeType);
}

public class PermanentEmployeeBasicSalary : BasicSalary
{
    public abstract double GetBasicSalary(EmployeeType employeeType) {...}
}

Open/Close

public abstract class BasicSalary
{
    public abstract double GetBasicSalary(EmployeeType employeeType);
}

public class PermanentEmployeeBasicSalary : BasicSalary
{
    public abstract double GetBasicSalary(EmployeeType employeeType) {...}
}

public class ContractEmployeeBasicSalary : BasicSalary
{
    public abstract double GetBasicSalary(EmployeeType employeeType) {...}
}

3. LSP — Liskov Substitution Principle:

Princípio da substituição de Liskov — Uma classe derivada deve ser substituível por sua classe base.

Se S é um subtipo de T, então os objetos do tipo T podem ser substituídos pelos objetos de tipo S sem que seja necessário alterar as propriedades deste programa.

Exemplos de violação do LSP:

• Sobrescrever/implementar um método que não faz nada;
• Lançar uma exceção inesperada;
• Retornar valores de tipos diferentes da classe base;

Seguir o LSP nos permite usar o polimorfismo com mais confiança. Podemos chamar nossas classes derivadas referindo-se à sua classe base sem preocupações com resultados inesperados.

public abstract class Vehicle
{
    public abstract void Drive();
}

public class Car : Vehicle
{
    public override void Drive() {...}
}

public class Jeep : Vehicle
{
    public override void Drive() {...}
}

public class Program
{
    public static void Main(string[] args)
    {
        Vehicle car = new Car();
        Vehicle truck = new Jeep();
    }
}

4. ISP — Interface Segregation Principle:

Princípio da Segregação da Interface — Uma classe não deve ser forçada a implementar interfaces e métodos que não irão utilizar.

Esse princípio basicamente diz que é melhor criar interfaces mais específicas ao invés de termos uma única interface genérica.

Antes:

public interface IPayment
{
    void ProcessPayment(decimal amount);

    void EnterCardDetails(string cardNumber, string expiryDate, string cvv);

    void EnterAccountDetails(string accountNumber, string routingNumber);
}

public class PaymentService : IPayment
{
    public void ProcessPayment(decimal amount) {...}

    public void EnterCardDetails(string cardNumber, string expiryDate, string cvv) {...}

    public void EnterAccountDetails(string accountNumber, string routingNumber) {...}
}

Depois:

public interface IPayment
{
    void ProcessPayment(decimal amount);
}

public interface ICreditCardPayment
{
    void VerififyCardDetails(string cardNumber, string expiryDate, string cvv);
}

public interface IBankTransferPayment
{
    void VerifyAccountDetails(string accountNumber, string routingNumber);
}

public class CreditCardPaymentService : IPayment, ICreditCardPayment
{
    public void ProcessPayment(decimal amount) {...}

    public void VerififyCardDetails(string cardNumber, string expiryDate, string cvv) {...}
}

public class BankTransferPaymentService : IPayment, IBankTransferPayment
{
    public void ProcessPayment(decimal amount) {...}

    public void VerifyAccountDetails(string accountNumber, string routingNumber) {...}
}

5. DIP — Dependency Inversion Principle:

Princípio da Inversão de Dependência — Dependa de abstrações e não de implementações.

De acordo com Uncle Bob, esse princípio pode ser definido da seguinte forma:

Módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender da abstração.

Abstrações não devem depender de detalhes. Detalhes devem depender de abstrações.

No contexto da programação orientada a objetos, é comum que as pessoas confundam a Inversão de Dependência (Princípio de Arquitetura) com a Injeção de Dependência (Design Pattern), porém são coisas distintas, mas que relacionam entre si com um proposito em comum, deixar o código desacoplado.

Inversão de Dependência: é a estratégia de depender de interfaces ou classes abstratas, ao invés de classes concretas.

Injeção de Dependência: usado para evitar o alto nível de acoplamento de código dentro de uma aplicação.

No código abaixo criamos a interface IEmailSender e herdamos ela na classe.

public interface IEmailSender
{
    void Send(string emailAddress, string message);
}

public class EmailSender: IEmailSender
{
    public void Send(string emailAddress, string message) {...}
}

Aqui está uma forma de utilizar o IEmailSender como injeção de dependência na classe NotificationService, recebendo como parâmetro.

public class NotificationService
{
    private IEmailSender _emailSender;

    public NotificationService(IEmailSender emailSender)
    {
        _emailSender = emailSender;
    }

    public void SendEmail(string emailAddress, string message)
    {
        _emailSender.Send(emailAddress, message);
    }
}

Linguagem Tipada

É uma linguagem em que todas as variáveis tem um tipo específico e podem ser divididas em fortemente tipadas como Java, C#, Fortran, Cobol e fracamente tipadas como PHP e JavaScript.
É executada diretamente pelo sistema operacional ou pelo processador, após ser tradudizo por meio de um processo.

Linguagem Interpretada

É quando o código fonte é executado por um programa de computador chamado interpretador, que em seguida é executado pelo sistema operacional ou processador, como JavaScript, Lua, PHP, Python.

Linguagem Compilada

É uma linguagem de programação em que o código fonte é executado diretamente pelo sistema operacional ou pelo processador, após ser traduzido por meio de um processo chamado compilação, usando um programa de computador chamado compilador, para uma linguagem de baixo nível, como linguagem de montagem ou código de máquina, como C, C++, C#, Delphi.

Acredito que todos nós temos algo a dizer e que ao compartilhar nossos conhecimentos, pensamentos e experiências, temos o poder de transformar a vida das pessoas.

Da minha parte, acredito que consigo ajudar simplificando alguns conceitos de tecnologia/desenvolvimento de software, trazendo isso de forma simples e compreensível, e com isso impactar, nem que seja em uma proporção menor essas pessoas.

“Eu posso aceitar o fracasso. Todo mundo falha em alguma coisa. Mas eu não posso aceitar não tentar.”
Michael Jordan

Este é o primeiro artigo que escrevo (o título não poderia ser outro), e espero que possa ser o primeiro de muitos. O principal tema será tecnologia, mas especificamente em desenvolvimento de software na linguagem C#, que é onde possui mais confiança e experiência, mas não deixa de ser referência também para outras linguagens.

Irei abordar diversos itens, como:

• Linguagem de programação
• Princípios e conceitos básicos da linguagem
• Estrutura de dados
• Design patterns
• Arquitetura de software
• Banco de dados
• Metodologias ágeis
• …

O conhecimento se torna maior quando é compartilhado e colaborativo. Se você achar que os artigos possam ser útil para alguém, compartilhe, vamos espalhar o conhecimento e levá-los mais longe. Sugestões são sempre bem-vindas e agrega valor a esse conhecimento.