https://github.com/piotrstenke/Durian
Durian is a collection of Roslyn-based analyzers and source generators that extend the default capabilities of C#.
https://github.com/piotrstenke/Durian
analysis csharp roslyn roslyn-analyzer source-generation
Last synced: about 1 month ago
JSON representation
Durian is a collection of Roslyn-based analyzers and source generators that extend the default capabilities of C#.
- Host: GitHub
- URL: https://github.com/piotrstenke/Durian
- Owner: piotrstenke
- License: mit
- Created: 2021-04-16T19:34:18.000Z (about 4 years ago)
- Default Branch: master
- Last Pushed: 2022-09-19T07:32:37.000Z (over 2 years ago)
- Last Synced: 2024-08-01T22:43:55.429Z (10 months ago)
- Topics: analysis, csharp, roslyn, roslyn-analyzer, source-generation
- Language: C#
- Homepage:
- Size: 4.06 MB
- Stars: 54
- Watchers: 3
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
- csharp-source-generators - Durian -   Extends the default capabilities of C# by mimicking features from other languages. (Source Generators / Other)
- RSCG_Examples - Durian
README
##
**Durian is a collection of Roslyn-based analyzers, source generators and utility libraries that greatly extend the default capabilities of C# by bringing new features found in other existing programing languages, such as Kotlin, Swift, Java, C++, and many more.**
## Table of Contents
1. [Current State](#current-state)
2. [Features](#features)
1. [DefaultParam](#defaultparam)
2. [InterfaceTargets](#interfacetargets)
3. [FriendClass](#friendclass)
4. [CopyFrom](#copyfrom)
3. [In Progress](#in-progress)
4. [Experimental](#experimental)
## Current State
Durian is still very much in development - many planned features are still not implemented or implemented only partially. Features that are production-ready are listed in the [Features](#Features) section below.
## Features
If you seek more information about a specific feature, click on its name below.
### [DefaultParam](src/Durian.DefaultParam/README.md)
*DefaultParam* allows to specify a default type for a generic parameter.
```csharp
using Durian;
public class Test<[DefaultParam(typeof(string))]T>
{
public T Value { get; }
public Test(T value)
{
Value = value;
}
}
public class Program
{
static void Main()
{
// Test can be used without type parameters - 'T' defaults to 'string'.
Test test1 = new Test("");
// Type parameter can be stated explicitly.
Test test2 = new Test("");
}
}
```
### [InterfaceTargets](src/Durian.InterfaceTargets/README.md)
*InterfaceTargets*, similar to how [System.AttributeUsageAttribute](https://docs.microsoft.com/en-us/dotnet/api/system.attributeusageattribute) works, allows to specify what kinds of types an interface can be implemented by.
```csharp
using Durian;
[InterfaceTargets(InterfaceTargets.Class)]
public interface ITest
{
}
// Success!
// ITest can be implemented, because ClassTest is a class.
public class ClassTest : ITest
{
}
// Error!
// ITest cannot be implemented, because StructTest is a struct, and ITest is valid only for classes.
public struct StructTest : ITest
{
}
```
### [FriendClass](src/Durian.FriendClass/README.md)
*FriendClass* allows to limit access to 'internal' members by specifying a fixed list of friend types.
```csharp
using Durian;
[FriendClass(typeof(A))]
public class Test
{
internal static string Key { get; }
}
public class A
{
public string GetKey()
{
// Success!
// Type 'A' is a friend of 'Test', so it can safely access internal members.
return Test.Key;
}
}
public class B
{
public string GetKey()
{
// Error!
// Type 'B' is not a friend of 'Test', so it cannot access internal members.
return Test.Key;
}
}
```
### [CopyFrom](src/Durian.CopyFrom/README.md)
*CopyFrom* allows to copy implementations of members to other members, without the need for inheritance. A regex pattern can be provided to customize the copied implementation.
```csharp
using Durian;
[CopyFromType(typeof(Other)), Pattern("text", "name")]
public partial class Test
{
}
public class Other
{
private string _text;
void Set(string text)
{
_text = text;
}
}
// Generated
partial class Test
{
private string _name;
void Set(string name)
{
_name = name;
}
}
```
## In Progress
The following modules are still in active development and are yet to be released in a not-yet-specified future.
## Experimental
Experimental stage is a playground of sorts - modules included here are very early in development and there in no guarantee that they will be ever actually released.
##
*\(Written by Piotr Stenke\)*