Build Robust and Maintainable Applications With Less Code.
The simplest and most powerful code generation and validation toolkit for C#.
- Write and maintain less code by eliminating boilerplate, generating it dynamically during compilation, typically reducing code lines and bugs by 15%.
- Validate your codebase against your own rules in real-time to enforce adherence to your architecture, patterns, and conventions. No need to wait for code reviews.
- Excel with large, complex, or old codebases. Metalama does not require you to change your architecture. Beyond getting started, it's at scale that it really shines.
What are boilerplate and architecture erosion costing you?
A Total Waste of Time
Manually writing boilerplate is not only boring and frustrating, but also a total waste of your time. Why manually do what a machine can accomplish more efficiently and swiftly?
Although allowing architecture to erode initially saves time, as it progressively accumulates, it makes everyone on the team less productive.
Excessive Complexity
If your business logic is cluttered with boilerplate, the source code becomes so complex that it's no longer comprehensible.
As the source code diverges from the original architecture, more exceptions to the rule are introduced, increasing the conceptual complexity of the source code.
Avoidable Defects
Boilerplate is often riddled with bugs because it's created by copy-paste programming and is largely untested. Production-readiness features such as logging or caching are neglected because they are too costly to build without the appropriate tools.
As the complexity of your codebase increases, its overall quality suffers: end-users encounter bugs and performance deteriorates.
Expensive Maintenance
As both boilerplate and architectural erosion contribute to increasing complexity, small changes to your application become increasingly expensive. A larger refactoring becomes completely unfeasible, necessitating a complete rewrite of your entire codebase.
Intelligent use of meta-programming could extend the lifespan of your codebase by several years.
Our Approach: Simple, Robust Meta-Programming
Meta-programming is the practice of writing code that generates, modifies, or validates other code. This approach streamlines repetitive tasks and makes code reviews more efficient.
With a focus on simplicity and safety, we have reimagined aspect-oriented programming (AOP) for modern .NET applications.
Aspects and fabrics are distinct C# classes that execute within the compiler or the IDE and perform the following tasks:
- Generate repetitive code at compile-time, ensuring your source code remains crystal clear;
- Verify source code against patterns and architectural rules, reporting errors in real-time;
- Suggest code fixes and refactorings, and provide guidance to developers.
Do it by your rules. Create your own code templates and verification rules easily and safely.
Show Me Code!
How Does It Work?
1. Add a Package to Your Project
Add the Metalama.Framework
package to your project.
Optionally, you can install Metalama Tools for Visual Studio to enhance your development experience.
2. Create an Aspect Class or Use an Open-Source One
Aspects are meta classes that transform code using simple C#-based templates. They can also report warnings and errors or suggest code fixes.
Here is an aspect that automatically adds logging to a method:
It may seem simplistic, and it is. Dozens of open-source aspects are available on Metalama Marketplace for you to use or modify.
3a. Add Aspects to Your Business Code One at a Time
You can apply each aspect individually using a custom attribute.
3b. Apply Aspects in Bulk Using a Fabric
Alternatively, you can apply aspects in bulk using compile-time LINQ-like code with a fabric.
A fabric is a specific kind of class that executes at build time or within the IDE. Unlike aspects, fabrics do not need to be applied to anything. They serve as their own entry points.
4. You're Done!
Upon compilation, Metalama seamlessly merges the aspect template with your business code. This process is executed on the fly to maintain the clarity of your source code.
Show Me More!
How Can I Validate Architecture?
1. Add the Architecture Package to Your Project
Add the Metalama.Extensions.Architecture
package to your project.
2. Add a Fabric Class
For instance, let's verify that internal members of the current namespace are only utilized within that namespace or from a unit test.
3. Your Code Is Now Validated In Real Time
A warning is now reported directly in the editor whenever you attempt to access an internal of a checked namespace from an unauthorized location.
Will I Still Understand My Code?
We believe that you will comprehend the business meaning of your code even better than before since it will not be cluttered with boilerplate. When the time comes to read the fine print, Metalama shows you the exact generated code. You can even debug it!
-
CodeLens: Effortlessly identify applied aspects within the editor, even when it's not evident from the source code.
-
Metalama Diff: Conveniently compare source and transformed code directly within Visual Studio.
-
Debugging Flexibility: Choose whether to step into the transformed code or stick to the source code during debugging.
-
Syntax Highlighting: Distinguish meta-code easily using T# syntax highlighting.
-
Interactive Querying: Utilize the Linqpad driver to query your codebase interactively, similar to a database, and analyze the behavior of your aspects and fabrics.
Delight Your Development Team
By harnessing the power of aspects and fabrics, coding architects and senior developers can act as force multipliers for the rest of the team. Metalama provides the tools to create a delightful development experience for the team, tailored to your project.
-
Instant Diagnostics: Receive immediate error and warning notifications directly within the editor, thanks to aspects.
-
Custom Fixes & Suggestions: Develop team-specific code fixes associated with diagnostic notifications.
-
Testing Framework: Test aspects on various target declarations with ease. The framework integrates seamlessly with the Visual Studio test runner.
-
Aspect Inheritance: Enable automatic propagation of aspects to child classes by annotating parent classes. This feature extends across projects.
-
Intellisense: Gain real-time access to aspect-introduced code, eliminating the need for recompilation.
-
Multi-Platform Compatibility: Compatible with Visual Studio, Visual Studio Code, Rider, and most build servers. Targets any .NET Standard 2.0-compatible platform.
We've Got You Covered
We've been there before. Metalama has been developed by a team with over 100 years of cumulative programming experience. This team has been supporting PostSharp, Metalama's predecessor, for more than 15 years.
-
No Vendor Lock-In: This feature allows for easy exportation of transformed code, facilitating the transition back to vanilla C# if necessary.
-
Extensibility with Roslyn: Metalama's limitations can be overcome by scripting transformations directly using Roslyn.
-
Open-Source or Source-Available: It is possible to step into Metalama's code under a source-available license. Extensions and aspect libraries are open source.