Preguntas sobre Desarrollo de Código Limpio

public class User {
    private String name;
    private String email;

    // Getters and setters
}

public class UserValidator {
    public boolean validate(User user) {
        // Validation logic
        return true;
    }
}

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        print("Drawing a circle")

class Square(Shape):
    def draw(self):
        print("Drawing a square")

public class Bird
{
    public virtual void Fly()
    {
        Console.WriteLine("Flying");
    }
}

public class Sparrow : Bird
{
    public override void Fly()
    {
        Console.WriteLine("Sparrow flying");
    }
}

interface Shape {
    draw(): void;
}

interface Scalable {
    scale(factor: number): void;
}

class Circle implements Shape, Scalable {
    draw() {
        console.log("Drawing a circle");
    }

    scale(factor: number) {
        console.log(`Scaling circle by ${factor}`);
    }
}

public interface NotificationService {
    void send(String message);
}

public class EmailNotificationService implements NotificationService {
    public void send(String message) {
        System.out.println("Sending email: " + message);
    }
}

public class User {
    private NotificationService notificationService;

    public User(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void notify(String message) {
        notificationService.send(message);
    }
}

def calculate_area_of_rectangle(width, height):
    return width * height

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }
}

// Calculates the area of a rectangle
function calculateArea(width: number, height: number): number {
    return width * height;
}

public class OldClass {
    // This method is not used anywhere
    public void oldMethod() {
        // old logic
    }
}

// Remove the unused method and class

def calculate_area(width, height):
    return width * height

# Use the function wherever needed
area1 = calculate_area(5, 10)
area2 = calculate_area(7, 3)

[TestClass]
public class CalculatorTests
{
    [TestMethod]
    public void Add_ValidInputs_ReturnsSum()
    {
        Calculator calc = new Calculator();
        int result = calc.Add(5, 3);
        Assert.AreEqual(8, result);
    }
}

public interface PaymentProcessor {
    void processPayment(double amount);
}

public class PayPalProcessor implements PaymentProcessor {
    public void processPayment(double amount) {
        System.out.println("Processing payment via PayPal");
    }
}

public class StripeProcessor implements PaymentProcessor {
    public void processPayment(double amount) {
        System.out.println("Processing payment via Stripe");
    }
}

# Module A
class A:
    def __init__(self, b):
        self.b = b

# Module B
class B:
    def __init__(self):
        self.a = A(self)

# Refactor to avoid circular dependency

public class User
{
    public string Name { get; set; }

    public string GetUserName()
    {
        return Name;
    }
}

// Use the class in a predictable way
User user = new User();
user.Name = "John";
Console.WriteLine(user.GetUserName());

public class Order {
    private List items;

    public void addItem(Item item) {
        items.add(item);
    }

    public double calculateTotal() {
        double total = 0;
        for (Item item : items) {
            total += item.getPrice();
        }
        return total;
    }
}

def calculate_discount(price, discount):
    if discount > 0:
        return price - (price * discount)
    return price

# Simplify conditional logic
def calculate_discount(price, discount):
    return price - (price * discount) if discount > 0 else price

public class TaxCalculator
{
    public double CalculateTax(double amount)
    {
        return amount * 0.2;
    }
}

public class Invoice
{
    private TaxCalculator taxCalculator = new TaxCalculator();

    public double CalculateTotal(double amount)
    {
        double tax = taxCalculator.CalculateTax(amount);
        return amount + tax;
    }
}

public class OrderService {
    private OrderRepository orderRepository;

    public void processOrder(Order order) {
        // Order processing logic
        orderRepository.save(order);
    }
}

public class OrderRepository {
    public void save(Order order) {
        // Save order to database
    }
}

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

# Avoid using exceptions for control flow
def calculate_division(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

public interface IDataProvider
{
    string GetData();
}

public class DataProvider : IDataProvider
{
    public string GetData()
    {
        return "Data";
    }
}

public class DataProcessor
{
    private IDataProvider dataProvider;

    public DataProcessor(IDataProvider dataProvider)
    {
        this.dataProvider = dataProvider;
    }

    public void Process()
    {
        string data = dataProvider.GetData();
        // Process data
    }
}

@Test
public void testCalculateArea() {
    double result = calculateArea(5, 10);
    assertEquals(50.0, result, 0.01);
}