It happens that we have to develop several services and deploy them in Azure. They are small, repetitive but different, often not very different. Why not use code generation techniques to simplify the development and implementation of these services? Let's see with .NET comes to meet us and helps us to deploy in Azure.

1. Marco Parenzan
marcoparenzan/CodeGenerationForAzureWithDotNet (github.com)

2. Senior Solution Architect in beanTech
Microsoft Azure MVP
Community Lead 1nn0va // Pordenone
1nn0va After Hour
https://bit.ly/1nn0va-video
Linkedin: https://www.linkedin.com/in/marcoparenzan/
Marco Parenzan

5. • Faster upgrades
• Framework (.NET 6.0 anyone?)
• Cloud Services
• Enforce (best) practices
• Increase maintainability
Challenges for the modern cloud company

6. • Service vs. Web Service
• Servicebusiness logic
• Web Serviceprotocol adaptation
• HTTPS vs GRPC
• Azure Function vs. API App
• Develop in front of a component
• Better testing
• Single Responsability Principle!
• Business logic and protocol adaptation are two responsabilities
Value vs. Not Value

7. • “Code that generates code…”
• Reflection
• Powerful
• Difficult to maintain
• Difficult to customize
• DSL
• Powerful
• Difficult to maintain
• Risk to customize
• Code Generation
• Powerful
• Simpler to maintain
• Simpler(?) to customize
Dynamic (Meta)Programming

8. • Text-based code generation
• T4
• Yeoman
• Razor
• Roslyn-based code generation
Code Generation Tecniques

10. CSC/VBC
Opening up the compiler
IL
AST
AST AST

11. Custom Diagnostic - Analyzer
private void Analyzer(SymbolAnalysisContext context)
{
var symbol = (INamedTypeSymbol)context.Symbol;
if (symbol.BaseType == null) return;
if ((symbol.BaseType.Name == "Controller"
|| symbol.BaseType.Name == "ApiController")
&& !symbol.Name.EndsWith("Controller"))
{
var diagnostic = Diagnostic.Create(
Rule, symbol.Locations[0], symbol.Name);
context.ReportDiagnostic(diagnostic);
}
}

12. C# Scripting / Interactive
var script = CSharpScript.Create<int>("int x = 1;")
.ContinueWith("int y = 2;")
.ContinueWith("x + y");
Assert.AreEqual(
3,
(int)(await script.RunAsync()).ReturnValue);

13. Building your own Fix
var value = 1 + 2;
ExpressionSyntax
SyntaxToken
SyntaxTrivia
var equalsValue =
SyntaxFactory.EqualsValueClause(
SyntaxFactory.BinaryExpression(
SyntaxKind.AddExpression,
SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)),
SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,SyntaxFactory.Literal(2))
));
var typeSyntax =
SyntaxFactory.VariableDeclaration(
SyntaxFactory.ParseTypeName("var"),
new SeparatedSyntaxList<VariableDeclaratorSyntax>()
.Add(SyntaxFactory.VariableDeclarator(“value")
.WithInitializer(equalsValue)))
.NormalizeWhitespace(" ")
.WithAdditionalAnnotations(Formatter.Annotation);
var declaration = SyntaxFactory.LocalDeclarationStatement(typeSyntax);

14. • - Extremely verbose
• + (Extremely) Statically Typed
• + Extremely meaningful
• Can be optimizedStatical VS refactoring
• C#6+ Era of immutability
• This is why some C# syntax exists
• Partial classes
• Partial methods
Roslyn code consideration

17. • Maintenance first!
• Maintenance first!
• Maintenance first!
• Maintenance first!
• Maintenance first!
• Maintenance first!
• Maintenance first!
• Maintenance first!
• Maintenance first!
• Maintenance first!
• Maintenance first!
Conclusions

18. • Creating code generators is not “mainstream”
• Using cg yes…Razor (again) is a code generator
• Don’t increase complexity
• Don’t implement infrequent situations
• manage infrequent situations with traditional classic manual code
• Roslyn
• Mature (everything Roslyn since C# 6.0+)
• Visual Studio Code Generators
• Difficult to test
• Develop outside Analyzer (whenever possible)
• Standard2.0 basedVisual Studio is .NET 4.8 (not core!!!!)
Conclusions

19. Marco Parenzan
marcoparenzan/CodeGenerationForAzureWithDotNet (github.com)