Dart Lesson 18: Advanced Object-Oriented Programming — Mixin

In previous lessons, we learned about file operations and command-line tool development, mastering practical skills for handling real-world development tasks. Today we'll dive into an advanced feature of Dart's object-oriented programming — Mixins. They are Dart's unique solution to code reuse and multiple inheritance problems, allowing us to organize and extend class functionality more flexibly.

I. Why Do We Need Mixins? — Solving the "Multiple Inheritance" Dilemma

In traditional object-oriented programming:

• Single inheritance (a class can only have one parent) limits code reuse flexibility
• Multiple inheritance (a class can have multiple parents) causes the "diamond problem" (ambiguity when multiple parents have methods with the same name)

Mixins were created to resolve this contradiction:

• They allow a class to "mix in" multiple functional modules, achieving effects similar to multiple inheritance
• But avoid multiple inheritance ambiguities through strict rules
• Focus on function reuse rather than class hierarchical relationships

A real-life example:

• Birds inherit from animals (single inheritance)
• But "ability to fly" and "ability to swim" are independent functions that shouldn't be inheritance relationships
• We can dynamically add "flying" or "swimming" capabilities to different birds using mixins (like ducks swimming and sparrows flying)

Code Comparison: Inheritance vs Mixins

// Limitations of traditional inheritance
class Animal {
  void eat() => print("Eating food");
}

// Properly define mixins with the mixin keyword
mixin Flyable {
  void fly() => print("Can fly");
}

mixin Swimmable {
  void swim() => print("Can swim");
}

// Solving with mixins: combine multiple capabilities with with keyword
class Duck extends Animal with Flyable, Swimmable {
  // Has eat(), fly(), and swim() methods
}

void main() {
  final duck = Duck();
  duck.eat(); // Output: Eating food
  duck.fly(); // Output: Can fly
  duck.swim(); // Output: Can swim
}

Note: In Dart, only classes defined with the mixin keyword can be used as mixins. Regular classes cannot be directly used as mixins, otherwise you'll get the "The class can't be used as a mixin" error.

II. Defining and Using Mixins

A mixin is essentially a special type of class that cannot be instantiated and is designed specifically to add functionality to other classes.

1. Defining Mixins

Define a mixin using the mixin keyword:

// Define a logging mixin
mixin Loggable {
  // Mixins can contain methods and properties
  void log(String message) {
    final time = DateTime.now().toIso8601String();
    print("[$time] $message");
  }
}

// Define a caching mixin
mixin Cacheable {
  final Map<String, dynamic> _cache = {};

  void cache(String key, dynamic value) {
    _cache[key] = value;
    print("Cached $key: $value");
  }

  dynamic getCache(String key) => _cache[key];
}

2. Using Mixins: The with Keyword

Add mixin functionality to a class using the with keyword:

// Regular class
class UserService {
  // Basic functionality: get user information
  String getUserInfo(int id) {
    return "Information for user $id";
  }
}

// Add functionality by mixing in Loggable and Cacheable
class EnhancedUserService extends UserService with Loggable, Cacheable {
  // Override parent method to add logging and caching
  @override
  String getUserInfo(int id) {
    // Use method from Loggable
    log("Starting to get information for user $id");

    // Check cache first
    final cached = getCache(id.toString());
    if (cached != null) {
      log("Retrieved information for user $id from cache");
      return cached;
    }

    // Actually get the information (call parent method)
    final info = super.getUserInfo(id);

    // Store in cache
    cache(id.toString(), info);
    log("Completed getting information for user $id");

    return info;
  }
}

void main() {
  final service = EnhancedUserService();

  // First retrieval (no cache)
  print(service.getUserInfo(100));

  // Second retrieval (with cache)
  print(service.getUserInfo(100));
}

// Output:
// [2023-10-20T10:00:00.000] Starting to get information for user 100
// Cached 100: Information for user 100
// [2023-10-20T10:00:00.001] Completed getting information for user 100
// Information for user 100
// [2023-10-20T10:00:00.002] Starting to get information for user 100
// [2023-10-20T10:00:00.002] Retrieved information for user 100 from cache
// Information for user 100

3. Mixin Rules and Limitations

Cannot be instantiated: Mixins are designed to be mixed in and cannot be directly instantiated

// Error! Cannot instantiate a mixin
// final log = Loggable();

Can restrict usage: Use the on keyword to specify that a mixin can only be used with subclasses of a specific class

class Base {
  void basic() => print("Basic method");
}

mixin Advanced on Base {
  // Restricted to subclasses of Base
  void advanced() {
    basic(); // Can call methods from Base class
    print("Advanced method");
  }
}

class MyClass extends Base with Advanced {
  // Correct: first inherit from Base, then mix in Advanced
}

// Error: OtherClass doesn't inherit from Base, cannot mix in Advanced
// class OtherClass with Advanced {}

Order matters with with: When multiple mixins have methods with the same name, later ones override earlier ones

mixin A {
  void method() => print("A");
}

mixin B {
  void method() => print("B");
}

class C with A, B {} // Later B overrides A

class D with B, A {} // Later A overrides B

void main() {
  C().method(); // Output: B
  D().method(); // Output: A
}

mixin class in Dart 2.17+: If you need a class that can function both as a regular class and as a mixin, use mixin class

mixin class Flyable {
  void fly() => print("Can fly");
}

// Can be inherited as a regular class
class Bird extends Flyable {}

// Can also be used as a mixin
class Insect with Flyable {}

III. Practical Scenarios: Dynamically Adding Functionality with Mixins

Mixins are ideal for adding common functionality to different classes, such as logging, caching, serialization, etc.

1. Logging Functionality Mixin

Add automatic logging capabilities to any class:

mixin Loggable {
  // Log method calls
  void logMethodCall(String methodName, [List<dynamic> args = const []]) {
    final argsStr = args.join(', ');
    print("[Calling method] $methodName($argsStr)");
  }

  // Log method returns
  void logMethodReturn(String methodName, dynamic result) {
    print("[Return result] $methodName: $result");
  }
}

// Apply to a data processing class
class DataProcessor with Loggable {
  int process(int a, int b) {
    logMethodCall("process", [a, b]);
    final result = a * 2 + b;
    logMethodReturn("process", result);
    return result;
  }
}

void main() {
  final processor = DataProcessor();
  processor.process(3, 5);
}

// Output:
// [Calling method] process(3, 5)
// [Return result] process: 11

2. Caching Functionality Mixin

Add caching capabilities to a network request class:

import 'dart:async';

// Cache mixin with expiration support
mixin Cacheable {
  final Map<String, _CacheItem> _cache = {};

  // Cache data
  void cacheData(String key, dynamic data, {Duration? expiration}) {
    _cache[key] = _CacheItem(
      data: data,
      expiration: expiration != null ? DateTime.now().add(expiration) : null,
    );
  }

  // Get cached data (returns null if expired)
  dynamic getCachedData(String key) {
    final item = _cache[key];
    if (item == null) return null;

    if (item.expiration != null && item.expiration!.isBefore(DateTime.now())) {
      _cache.remove(key); // Remove expired cache
      return null;
    }

    return item.data;
  }
}

// Internal cache item class
class _CacheItem {
  final dynamic data;
  final DateTime? expiration;

  _CacheItem({required this.data, this.expiration});
}

// Network request class
class ApiClient with Cacheable {
  // Simulate network request
  Future<String> fetchData(String url) async {
    // Check cache first
    final cached = getCachedData(url);
    if (cached != null) {
      print("Retrieved from cache: $url");
      return cached;
    }

    // Simulate network delay
    await Future.delayed(Duration(seconds: 1));
    final result = "Data from $url";

    // Cache for 10 seconds
    cacheData(url, result, expiration: Duration(seconds: 10));
    print("Fetched and cached: $url");

    return result;
  }
}

void main() async {
  final api = ApiClient();

  // First request (network)
  print(await api.fetchData("https://api.example.com/user"));

  // Second request (cache)
  print(await api.fetchData("https://api.example.com/user"));
}

3. Combining Multiple Mixins

A class can mix in multiple functionalities simultaneously for flexible feature combination:

// Printable functionality
mixin Printable {
  void printInfo() => print(toString());
}

// Cloneable functionality
mixin Cloneable<T> {
  T clone();
}

// Data model class
class User with Printable, Cloneable<User> {
  final String name;
  final int age;

  User({required this.name, required this.age});

  @override
  String toString() => "User(name: $name, age: $age)";

  @override
  User clone() {
    return User(name: name, age: age);
  }
}

void main() {
  final user = User(name: "Alice", age: 25);

  // Use Printable functionality
  user.printInfo(); // Output: User(name: Alice, age: 25)

  // Use Cloneable functionality
  final user2 = user.clone();
  user2.printInfo(); // Output: User(name: Alice, age: 25)
}

IV. Comparing Mixins with Other Code Reuse Approaches

Approach	Characteristics	Suitable Scenarios
Inheritance	Single inheritance, emphasizes "is-a"	Clear hierarchical relationships
Mixin	Multiple mixins, emphasizes "has-a capability"	Adding common features to different classes
Interface	Defines only contracts, no implementation	Specifying methods classes must implement
Composition	Contains object as member, "has-a"	Modular combination of complex features

Best practices:

• Prefer composition and mixins for code reuse
• Use inheritance carefully to avoid deep hierarchies
• Use interfaces to define specifications ensuring consistent behavior across classes

V. Common System Mixins in Dart

Dart's standard library includes several useful mixins:

• ObjectWithHashCode: Helps implement hash codes
• IterableMixin: Simplifies iterator implementation
• ListMixin: Simplifies list implementation

Example: Using ListMixin to quickly implement a custom list

import 'dart:collection';

// Custom list that only allows even numbers
class EvenList with ListMixin<int> {
  final List<int> _list = [];

  @override
  int length = 0;

  @override
  int operator [](int index) => _list[index];

  @override
  void operator []=(int index, int value) {
    if (value % 2 != 0) {
      throw ArgumentError("Only even numbers allowed");
    }
    _list[index] = value;
  }

  @override
  void add(int value) {
    if (value % 2 != 0) {
      throw ArgumentError("Only even numbers allowed");
    }
    _list.add(value);
    length++;
  }
}

void main() {
  final evenList = EvenList();
  evenList.add(2);
  evenList.add(4);
  print(evenList); // Output: [2, 4]

  // Trying to add odd number will throw error
  try {
    evenList.add(3);
  } catch (e) {
    print(e); // Output: Invalid argument(s): Only even numbers allowed
  }
}