สรุป 6 Pillars of code quality

• C#

// C# - readable example
public class Order
{
    public int Id { get; init; }
    public decimal Amount { get; init; }
}

public interface IPaymentGateway
{
    bool Charge(decimal amount);
}

public class OrderService
{
    private readonly IPaymentGateway _gateway;

    public OrderService(IPaymentGateway gateway) => _gateway = gateway;

    // ชื่อเมธอดชัดเจน: ProcessOrder => ทำอะไรบ้างเห็นได้ชัด
    public bool ProcessOrder(Order? order)
    {
        if (order == null) throw new ArgumentNullException(nameof(order));
        if (order.Amount <= 0) return false;

        return _gateway.Charge(order.Amount);
    }
}

• Spring

// Spring - readable example
@Service
public class OrderService {
    private final PaymentGateway paymentGateway;

    public OrderService(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
    }

    // ชื่อเมธอดและพารามิเตอร์ชัดเจน
    public boolean processOrder(OrderDto order) {
        if (order == null) throw new IllegalArgumentException("order required");
        if (order.getAmount().compareTo(BigDecimal.ZERO) <= 0) return false;

        return paymentGateway.charge(order.getAmount());
    }
}

• Golang

// Go - readable example
package orders

type Order struct {
    ID     int
    Amount float64
}

type PaymentGateway interface {
    Charge(amount float64) bool
}

type Service struct {
    gateway PaymentGateway
}

func NewService(g PaymentGateway) *Service {
    return &Service{gateway: g}
}

func (s *Service) ProcessOrder(o *Order) bool {
    if o == nil || o.Amount <= 0 {
        return false
    }
    return s.gateway.Charge(o.Amount)
}

• C#

// Avoid surprises: do not mutate input and return clear result
public class StringUtils
{
    // ไม่เปลี่ยน string ที่ส่งมา (immutable)
    public static string Normalize(string? input)
    {
        if (input == null) return string.Empty;
        return input.Trim().ToLowerInvariant();
    }
}

• Spring

// Avoid surprises: return Optional instead of nulls, explicit transactional boundaries
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

@Service
@Transactional(readOnly = true)
public class UserService {
    private final UserRepository repo;
    public UserService(UserRepository repo) { this.repo = repo; }

    public Optional<UserDto> findByEmail(String email) {
        return repo.findByEmail(email).map(UserDto::fromEntity);
    }
}

• Golang

// Avoid surprises: explicit error returns, no panics
func ParseAmount(s string) (float64, error) {
    if s == "" {
        return 0, fmt.Errorf("empty amount")
    }
    a, err := strconv.ParseFloat(s, 64)
    if err != nil {
        return 0, fmt.Errorf("invalid amount: %w", err)
    }
    return a, nil
}

• C#

public string GetStatus(DateTime currentTime) => currentTime.Hour > 17 ? "Closed" : "Open";

• Spring

public String getStatus(LocalDateTime currentTime) {
    return currentTime.getHour() > 17 ? "Closed" : "Open";
}

• Golang

func GetStatus(currentTime time.Time) string {
    if currentTime.Hour() > 17 {
        return "Closed"
    }
    return "Open"
}

• C#

// Make misuse harder: immutable value object + factory
public class Email
{
    public string Value { get; }
    private Email(string value) => Value = value;

    public static Email Create(string email)
    {
        if (string.IsNullOrWhiteSpace(email)) throw new ArgumentException("email empty");
        if (!email.Contains("@")) throw new ArgumentException("invalid email");
        return new Email(email.Trim().ToLowerInvariant());
    }
}

• Spring

// Make misuse harder: DTO validation + @Validated service
public class CreateUserRequest {
    @NotBlank
    @Email
    private String email;
    // getters/setters
}

@RestController
@RequestMapping("/users")
public class UserController {
    @PostMapping
    public ResponseEntity<Void> createUser(@Valid @RequestBody CreateUserRequest req) {
        // Spring will validate automatically; invalid payload -> 400
        // ... create user
        return ResponseEntity.status(HttpStatus.CREATED).build();
    }
}

• Golang

// Make misuse harder: unexported fields + constructor that validates
type Config struct {
    host string
    port int
}

func NewConfig(host string, port int) (*Config, error) {
    if host == "" { return nil, fmt.Errorf("host required") }
    if port <= 0 { return nil, fmt.Errorf("invalid port") }
    return &Config{host: host, port: port}, nil
}

// users outside package cannot set fields directly

• C#

public readonly record struct Money
{
    public decimal Amount { get; init; }
    public string Currency { get; init; }

    public Money(decimal amount, string currency)
    {
        if (amount < 0) throw new ArgumentException("Money cannot be negative");
        if (string.IsNullOrWhiteSpace(currency)) throw new ArgumentException("Currency is required");
        
        Amount = amount;
        Currency = currency;
    }

    // You can Encapsulation Logic Business Logic
    public Money Add(Money other)
    {
        if (this.Currency != other.Currency)
            throw new InvalidOperationException("Cannot add different currencies");
            
        return new Money(this.Amount + other.Amount, this.Currency);
    }
}

• Java

public record Money(BigDecimal amount, String currency) {
    public Money {
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Amount cannot be negative");
        }
        if (currency == null || currency.isBlank()) {
            throw new IllegalArgumentException("Currency is required");
        }
    }

    // You can Encapsulation Logic Business Logic
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalStateException("Currencies do not match");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
}

• Golang

package finance

import (
	"errors"
	"fmt"
)

// Money is a value object. Fields are unexported/private (lowercase) 
type Money struct {
	amount   float64
	currency string
}

// NewMoney acts as a "Fail Fast" factory to create a object from outside this package.
func NewMoney(amount float64, currency string) (Money, error) {
	if amount < 0 {
		return Money{}, errors.New("amount cannot be negative")
	}
	if currency == "" {
		return Money{}, errors.New("currency is required")
	}
	return Money{amount: amount, currency: currency}, nil
}

// Methods as business logic.
func (m Money) Add(other Money) (Money, error) {
	if m.currency != other.currency {
		return Money{}, fmt.Errorf("cannot add %s to %s", other.currency, m.currency)
	}
	return Money{amount: m.amount + other.amount, currency: m.currency}, nil
}

// Getter methods provide read-only access, maintaining immutability.
func (m Money) Amount() float64 { return m.amount }
func (m Money) Currency() string { return m.currency }

• C#

//interface + DI
public interface IOrderRepository { Order Get(int id); void Save(Order o); }
public class OrderRepository : IOrderRepository { /* db logic */ }

public class OrderController
{
    private readonly OrderService _service;
    public OrderController(OrderService service) { _service = service; }

    public IActionResult PlaceOrder(OrderDto dto) {
        // controller delegates to service
        _service.ProcessOrder(dto.ToOrder());
        return new Ok();
    }
}

• Spring

//Controller -> Service -> Repository
@RestController
@RequestMapping("/orders")
public class OrderController {
    private final OrderService service;
    public OrderController(OrderService service) { this.service = service; }

    @PostMapping
    public ResponseEntity<Void> placeOrder(@RequestBody OrderDto dto) {
        service.placeOrder(dto);
        return ResponseEntity.ok().build();
    }
}

• Golang

// packages: package orders and package payment
// orders.Service depends on payment.Gateway interface
package orders

type Gateway interface { Charge(amount float64) bool }

type Service struct {
    gateway Gateway
}
// in other package implement Gateway, provide to Service via NewService

Improve Code, Example

• C#

//generic Result<T> for operations
public class Result<T>
{
    public bool IsSuccess { get; }
    public T Value { get; }
    public string Error { get; }
    // constructors/factories...
}

• Spring

//generic paging/util component
public class PageResult<T> {
    private List<T> items;
    private int total;
    // getters/setters
}

• Golang - แต่อันนี้นานาจิตตะ บางส่วนมองว่า Simple is the best ตอนเชียน Blog ผมก็สงสัยหน้าตามันไม่เหมือน พวก dotnet / spring

//Required Go 1.18+ generics
package slices

func Map[T any, R any](in []T, fn func(T) R) []R {
    out := make([]R, 0, len(in))
    for _, v := range in { out = append(out, fn(v)) }
    return out
}

• C#

// C# unit test using xUnit and Moq
public class OrderServiceTests
{
    [Fact]
    public void ProcessOrder_ValidOrder_ChargesGateway()
    {
        var mock = new Mock<IPaymentGateway>();
        mock.Setup(g => g.Charge(It.IsAny<decimal>())).Returns(true);

        var svc = new OrderService(mock.Object);
        var order = new Order { Id = 1, Amount = 100m };

        var result = svc.ProcessOrder(order);

        Assert.True(result);
        mock.Verify(g => g.Charge(100m), Times.Once);
    }
}

• Spring

// Spring controller unit test
@WebMvcTest(OrderController.class)
class OrderControllerTest {
    @Autowired MockMvc mvc;
    @MockBean OrderService service;

    @Test
    void postOrder_callsService() throws Exception {
        String json = "{\"id\":1,\"amount\":100}";
        mvc.perform(post("/orders").contentType(MediaType.APPLICATION_JSON).content(json))
           .andExpect(status().isOk());
        verify(service).placeOrder(any());
    }
}

• Golang - Table-Driven Tests

// Go unit tests (table-driven)
func TestParseAmount(t *testing.T) {
    tests := []struct{
        input string
        want float64
        wantErr bool
    }{
        {"12.5", 12.5, false},
        {"", 0, true},
        {"abc", 0, true},
    }

    for _, tt := range tests {
        got, err := ParseAmount(tt.input)
        if (err != nil) != tt.wantErr {
            t.Fatalf("input=%q expected err=%v got=%v", tt.input, tt.wantErr, err)
        }
        if !tt.wantErr && got != tt.want {
            t.Fatalf("input=%q want %v got %v", tt.input, tt.want, got)
        }
    }
}