Flutterexperts

Dart’s metadata annotations provide our code with more details. This information can be used by the Dart runtime, tools, or libraries. Code generation, documentation, and runtime behaviour adjustment are just a few of the things that these annotations can assist with.

This blog will explore Metadata Annotations in Dart. We will also implement a demo program and teach you how to use generation, documentation, and runtime in Dart for your applications.

If you’re looking for the best Flutter app development company for your mobile application then feel free to contact us at — support@flutterdevs.com.

---

Table Of Contents::

What Are Metadata Annotations

Using Metadata Annotations

Code Implement

Conclusion

---

---

What Are Metadata Annotations:

The @ symbol and the class name, which may contain constructor arguments, are used in Dart to create metadata annotations. These annotations can be applied to fields, parameters, classes, or methods. Dart comes with several built-in annotations. Custom annotations can be defined by us.

This is an illustration of a basic metadata annotation:

@deprecated
void newMethod() {
}

Using Metadata Annotations:

Developers in Flutter make extensive use of metadata annotations to add more details about classes, methods, and widgets.

• @required: This signifies that to invoke a method, a parameter must be supplied.
• @deprecated: Indicates that a feature is no longer supported.
• @override: Shows that a method in a superclass is being overridden.
• @optional: This means that a variable or method is only for internal use and shouldn’t be directly accessed.
• @protected: This signifies that a variable or method is only for internal use and shouldn’t be directly accessed.
• @visibleForTesting: This signifies that a variable or method is exclusively for testing and shouldn’t be directly accessed.

An illustration of the usage of the @required annotation in Flutter is provided here:

class MyWidget extends StatelessWidget {
  final String title;

  MyWidget(@required this.title);

  @override
  Widget build(BuildContext context) {
    return Text(title);
  }
}

Code Implement:

=> Creating Custom Annotations

It’s easy to create a custom annotation in Dart. We specify a parameter-accepting class. We use instances of this class to annotate our code.

=> Defining a Custom Annotation

To provide classes or methods with descriptive information, we will develop a new annotation named @CustomAnnotations.

class CustomAnnotations {
  final String description;

  const Info(this.description);
}

Here, we define CustomAnnotations, a custom metadata annotation that accepts a description argument. We can apply this annotation to a class or method to use it:

@CustomAnnotations('This is a custom annotation')
class DemoClass {
  @CustomAnnotations('This is a annotation example')
  int add(int a, int b) => a + b;
  @CustomAnnotations('Subtracts the second number from the first.')
  int subtract(int a, int b) => a - b;
}

=> Using Metadata Annotations for Code Generation

By using the dart:mirrors package, we can take advantage of Dart’s reflection capabilities to access metadata annotations at runtime. It’s crucial to remember that dart:mirrors has restrictions, especially when used in online applications that use tree shaking. Here’s how to get our personalised annotations back:

import 'dart:mirrors';

void getAnnotations(Type type) {
  final classMirror = reflectClass(type);
  final classAnnotations = classMirror.metadata;

  for (var annotation in classAnnotations) {
    if (annotation.reflectee is CustomAnnotations) {
      final CustomAnnotations = annotation.reflectee as CustomAnnotations;
      print('Class Annotation: ${CustomAnnotations.description}');
    }
  }

  // Check method annotations
  classMirror.declarations.forEach((key, value) {
    if (value is MethodMirror) {
      final methodAnnotations = value.metadata;
      for (var annotation in methodAnnotations) {
        if (annotation.reflectee is CustomAnnotations) {
          final customAnnotations = annotation.reflectee as CustomAnnotations;
          print('Method ${MirrorSystem.getName(key)} Annotation:             ${customAnnotations.description}');
        }
      }
    }
  });
}

void main() {
  getAnnotations(DemoClass);
}

When we run the application, we ought to get the above code output like the underneath console output the annotations associated with the DemoClass class and its methods:

Class Annotation: This is a custom annotation
Method demo Annotation: This is a annotation example
Method subtract Annotation: Create a demo class for annotation example

Conclusion:

In the article, I have explained the Metadata Annotations basic structure in a dart; you can modify this code according to your choice. This was a small introduction to the Metadata Annotations On User Interaction from my side, and it’s working using Dart.

I hope this blog will provide you with sufficient information on Trying the Metadata Annotations in Dart in your projects. Dart’s robust custom annotations feature lets us add metadata to our classes and functions, making our code easier to read and maintain. So please try it.

❤ ❤ Thanks for reading this article ❤❤

If I got something wrong? Let me know in the comments. I would love to improve.

Clap 👏 If this article helps you.

---

Feel free to connect with us:
And read more articles from FlutterDevs.com.

FlutterDevs team of Flutter developers to build high-quality and functionally-rich apps. Hire Flutter developer for your cross-platform Flutter mobile app project on an hourly or full-time basis as per your requirement! For any flutter-related queries, you can connect with us on Facebook, GitHub, Twitter, and LinkedIn.

We welcome feedback and hope that you share what you’re working on using #FlutterDevs. We truly enjoy seeing how you use Flutter to build beautiful, interactive web experiences.

---