Skip to content

Mixins in Dart Explained

Dart, Mixins, Object-Oriented Programming1 min read

Mixins are a powerful feature of the Dart programming language that enable the reuse of code across multiple classes without requiring inheritance. This allows developers to create modular and maintainable codebases by separating concerns and reducing duplication.

What are Mixins?

In Dart, a mixin is a special kind of class that provides a set of methods and/or fields that can be used by other classes without inheriting from it. Instead, mixins are used through a process called mixin application, where the methods and fields of the mixin are combined with the members of the class.

To define a mixin in Dart, you use the mixin keyword followed by the name of the mixin and its body:

1mixin MyMixin {
2 // Define some methods and fields

Mixins can be applied to a class using the with keyword:

1class MyClass with MyMixin {
2 // Class definition here

Once the mixin has been applied to the class, the methods and fields defined in the mixin become available in the class as if they were part of the class itself.


Let's see some examples of how mixins can be used in Dart.

Logging Mixin

Suppose you have a set of classes that perform some complex operations and you want to keep track of the order in which these operations are executed. You could use a mixin to add logging functionality to these classes:

1mixin LoggingMixin {
2 void log(String message) {
3 print('${}: $message');
4 }
7class MyComplexClass with LoggingMixin {
8 void performOperation1() {
9 log('Performing operation 1...');
10 // Perform operation 1 here
11 }
13 void performOperation2() {
14 log('Performing operation 2...');
15 // Perform operation 2 here
16 }
18 // Other methods...

In this example, the LoggingMixin defines a single method log that prints a timestamped message to the console. The MyComplexClass uses the with keyword to apply the mixin, and then calls the log method at key points in its own methods.

Equatable Mixin

Another common use case for mixins is to add equality testing functionality to classes. The Equatable mixin provided by the equatable package is a good example of this:

1import 'package:equatable/equatable.dart';
3class MyClass extends Equatable {
4 final int value;
6 MyClass(this.value);
8 @override
9 List<Object?> get props => [value];

In this example, the MyClass extends the Equatable class and overrides its props getter to return a list of properties that should be used to test for equality. The Equatable mixin provides an implementation of == and hashCode methods that compare these properties.

In closing - mixins are a powerful feature of Dart that can greatly improve code reuse and modularity in object-oriented programming. By separating concerns into reusable components, developers can create more maintainable and extensible codebases. If you're new to mixins, I encourage you to experiment with them in your projects and see how they can make your code more modular and reusable.