Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/farskeptic/AutoCompose
AutoCompose is a .NET source generator that enables composition without having to implement pass-thru code. There is no runtime reflection.
https://github.com/farskeptic/AutoCompose
Last synced: about 1 month ago
JSON representation
AutoCompose is a .NET source generator that enables composition without having to implement pass-thru code. There is no runtime reflection.
- Host: GitHub
- URL: https://github.com/farskeptic/AutoCompose
- Owner: farskeptic
- License: mit
- Created: 2024-03-02T19:17:09.000Z (9 months ago)
- Default Branch: main
- Last Pushed: 2024-04-26T22:43:18.000Z (8 months ago)
- Last Synced: 2024-08-01T22:43:03.959Z (4 months ago)
- Language: C#
- Size: 81.1 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- RSCG_Examples - https://github.com/farskeptic/AutoCompose
README
# AutoCompose
[](https://www.nuget.org/packages/FarSkeptic.AutoCompose/)
[](https://www.nuget.org/packages/FarSkeptic.AutoCompose/)
[](https://github.com/farskeptic/AutoCompose/blob/main/LICENSE)
[](https://www.nuget.org/packages/FarSkeptic.AutoCompose/)
[](https://github.com/sponsors/farskeptic)
[](https://github.com/farskeptic/autocompose)
AutoCompose is a .NET source generator that allows the implementation of an interface via composition without having to implement pass-thru code. There is no runtime reflection.
- All unimplemented properties and methods on the interface are automatically generated as pass-thru logic.
- Any implemented properties or methods will NOT be generated by AutoCompose.
- As you add or remove implementations, AutoCompose re-generates to compensate.
This allows object composition to be used as easily as inheritance.
# Getting Started
Given an interface named **ISample**:
Create a class implementing **ISample** via composition using AutoCompose by:
1. Implementing a partial class
1. Adding the instance of the interface as a member variable (e.g. _sample)
1. Injecting the variable in the constructor
1. Decorating the class with the AutoCompose attribute
```csharp
[AutoCompose(typeof(ISample), "_sample")]
public partial class Sample: ISample
{
protected ISample _sample;
// all non-implemented properties and methods are automatically generated as pass-thru logic
public Sample(ISample sample)
{
_sample = sample;
}
:
}
```
AutoCompose runs at compile time, and generates the source required to fully implement the interface.
# Composition as easily as Inheritance
When trying to decide between inheritance or composition, the amount of pass-thru code that must be coded and maintained often plays a role in the decision.
Example: When we need to override the implementation of a single method for an interface that contains 10 methods, the code burden of implementing and maintaing the 9 pass-thru methods often causes developers to choose inheritance over composition, regardless of other considerations.
**With AutoCompose, this issue goes away. The developer is free to choose inheritance or composition for purely architectural reasons, without having to worry about implementation or maintenance difficulties.**
# When should I use AutoCompose?
Any time you want to use composition, and have at least one property or method that would be implemented as pass-thru code, AutoCompose can take that burden away from you.
# Known Limitations
1. AutoCompose currently works for interfaces only. It DOES NOT work (yet) for abstract classes.
1. AutoCompose may not work if your code has multiple definitions of an interface with the same name. AutoCompose (currently) just picks the first matching symbol, and so does not discriminate the target-interface based purely on namespaces.
1. If your code contains extremely deep namespaces and would generate source code files with very long names, then there can be filename-length conflicts with the windows file system.
1. If your interface contains references to classes or structures in other nuget packages, there can be problems generating, and insufficient error messages are given.