Clean Code - Part II: The Four Principles (of Art)

using System;

namespace PrincipleOfRepetition
{
    public class Pizza
    {
        private readonly List<string> _pizzaToppings;
        private readonly List<string> _pizzaSides;
        private readonly decimal _price;

        public Pizza(string size)
        {
            SetInitialPrice(size);
        }

        public void AddTopping(string topping) // Both methods of adding to a collection 
            => _pizzaToppings.Add(topping);    // repeat the same mental concept.

        public void AddSide(string side)
            => _pizzaSides.Add(side);

        public decimal GetPrice() => _price;

        private void SetInitialPrice(string size)
            => _price = size switch {
                "S" => 5.99m,
                "M" => 7.99m,
                "L" => 10.99m,
                _ => throw new ArgumentOutOfRangeException($"Pizza size not supported with value of {size}.")
            };
    }

    // Both Hamburger and Pizza repeat the same language of how to interact with them.
    // "Add" "Get" "Set"
    // The verbs themselves aren't as important as long as they are repeated all throughout the project.
    // Use OOP principles like abstraction to turn this repetition into a pit of success for others.
    // We could implement base abstract classes or interfaces to enforce these naming and functionality patterns.
    // This could be a good spot for a Decorator pattern or a Factory pattern if appropriate.
    // Design patterns are another form of repetition.
    public class Hamburger 
    {
        // Private fields float to the top.
        private readonly List<string> _burgerToppings; // Underscores for private fields with a camelCase convention.
        private readonly List<string> _burgerSides;
        private readonly decimal _price;

        // Constructor is next.
        public Hamburger(string size)
        {
            SetInitialPrice(size);
        }

        // Publicly called methods are next.
        public void AddTopping(string topping)
            => _burgerSides.Add(topping);      

        public void AddSide(string side)
            => _burgerToppings.Add(side);

        public decimal GetPrice() => _price;

        // Private methods sink to the bottom.
        private void SetInitialPrice(string size)
            => _price = size switch {
                "1/4" => 3.75m,
                "1/3" => 4.50m,
                "1/2" => 5.00m,
                _ => throw new ArgumentOutOfRangeException($"Hamburger size not supported with value of {size}.")
            };
    }
}

namespace PrincipleOfAlignment
{
    public class ShoppingBot
    {
        public void SizeOfClothes() {
            // Identation helps naturally to keep our field of vision narrow - like reading blocks of code in a method.
            var viewModel = new ClothesViewModel();

            Console.WriteLine("Enter your shirt size"); 
            var shirtSize = Console.ReadLine();
            viewModel.ShirtSize = shirtSize;

            Console.WriteLine("Enter your shoe size");
            var shoeSize = Console.ReadLine();
            viewModel.ShoeSize = shoeSize;
        }

        public void ShippingAddress_NoAlignment(string lineOne, string lineTwo, string lineThree, string city, string state, string zip)
        {

        }

        public void ShippingAddress_Alignment(
            string lineOne,
            string lineTwo,
            string lineThree,
            string city,
            string state,
            string zip
        )
    }

    public class ClothesViewModel
    {
        // Humans have an easier time understanding a complete thought when it is aligned horizontally than they do vertically.
        // Imagine
        // Trying
        // To
        // Read
        // A
        // Book
        // Like
        // This

        // For lots of properties (like in DTOs or view models)
        // having a complete thought aligned on one line is a lot easier to read
        // - unlike this comment.

        [Required] public string ShirtSize { get; set; }
        [Required] public string ShoeSize { get; set; } 

        // Versus

        [Required]
        public string ShoeSize
        {
            get;
            set;
        }

        // Remember to stay pragmatic about this. For example, I wouldn't keep the horizontal alignment for properties with multiple attributes if it got too long.
        // This also ties directly into the Principle of Proximity.
    }
}

namespace PrincipleOfProximity 
{
    public class AddressRepository 
    {
        private readonly DbContext _dbContext;
        private readonly IAddressValidationService _addressValidationService;
        private readonly ILogger<AddressRepository> _logger;

        public AddressRepository(DbContext dbContext, IAddressValidationService addressValidationService, ILogger<AddressRepository> logger)
        {
            _dbContext = dbContext;
            _addressValidationService = addressValidationService;
            _logger = logger;
        }

        public async Task<string> AddAsync_Proximity(string lineOne, string lineTwo, string city, string state, string zip, CancellationToken cancellationToken = default)
        {
            var address = new Address(lineOne, lineTwo, city, state, zip);

            var isValidAddress = _addressValidationService.IsValid(address);
            if (isValidAddress)
            {
                _dbContext.Addresses.Add(address);
                _dbContext.SaveChangesAsync(cancellationToken);

                _logger.LogDebug($"Address of {address.ToString()} was added.")

                return "Saved address successfully.";
            }

            _logger.LogWarning($"Address of {address.ToString()} was not saved successfully.");

            return "Address was not valid - unable to save address.";
        }

        public async Task<string> AddAsync_NoProximity(string lineOne, string lineTwo, string city, string state, string zip, CancellationToken cancellationToken = default)
        {
            var address = new Address(lineOne, lineTwo, city, state, zip);
            var isValidAddress = _addressValidationService.IsValid(address);
            if (isValidAddress)
            {
                _dbContext.Addresses.Add(address);
                _dbContext.SaveChangesAsync(cancellationToken);
                _logger.LogDebug($"Address of {address.ToString()} was added.")
                return "Saved address successfully.";
            }
            _logger.LogWarning($"Address of {address.ToString()} was not saved successfully.");
            return "Address was not valid - unable to save address.";
        }
    }

    public class Address 
    {
        public Address(string lineOne, string lineTwo, string city, string state, string zip)
            => (LineOne, LineTwo, City, State, Zip) = (lineOne, lineTwo, city, state, zip);

        public string LineOne { get; set; }
        public string LineTwo { get; set; }
        public string City { get; set; }
        public string State { get; set; }
        public string Zip { get; set; }

        public override string ToString() => $"{lineOne} {lineTwo} {city} {state}, {zip}";
    }
}