Generics vs dynamic

Learn the difference between generics and dynamic.

Generics vs dynamic

Generics fix the type at compile time; dynamic leaves the type to runtime. Both give flexibility but the safety level differs.

When you declare List<int>, the compiler knows the list holds only int; list.add('a') is a compile error. When you declare List<dynamic>, any type can be added; the error surfaces only at runtime, when the value is accessed. Generics catch the error early; dynamic is flexible but risky. For maintainable code, generics are preferred.

When to use which?

Generics are the default choice for collections and helper methods; they give type safety and readability. Declarations like List<int> and Map<String, int> surface errors at compile time.

dynamic is for cases where the type is not known up front: external data sources, reflection or temporary prototype code. But in production code dynamic should be a last resort. Generics give a contract to the compiler and the reader; dynamic removes that contract. The right choice is generics, which keeps safety.

Exercise Write a generic pick<T> method

Define a generic method named T pick<T>(List<T> items, int i); its body should be return items[i];. In main, call print(pick<int>([1, 2, 3], 1));.

Show example solution

// Define the pick<T> method
T pick<T>(List<T> items, int i) {
  return items[i];
}

void main() {
  print(pick<int>([1, 2, 3], 1));
}

Test yourself

Match generics and dynamic properties

Generic

Compile-time safety
dynamic

Runtime check
List<int>

Fixed type

Build a type-safe list

var ages = <____>[28, 30];
print(ages[0]);

Show answer

var ages = <int>[28, 30];
print(ages[0]);

Which is the safest choice?
- List<dynamic>
- List<int>
- dynamic x
- var x = 5
Show answer

List<int> — List<int> fixes the type at compile time; it is the safest choice.

Next lesson: Summary - Generics

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies