Prezentare 1: Introducere in Aspire, https://github.com/dotnet/aspire
Prezentator: Andrei Ignat, http://msprogrammer.serviciipeweb.ro/
Prezentare 2: La ce e bun Dapr si de ce ar trebui sa ma intereseze?
Prezentator: Alex Mang , https://www.linkedin.com/in/iamalexmang/
Va astept pe
https://meet.google.com/zqu-hcyh-vwe
Multumesc
Andrei
RSCG – Fluentify
| name | Fluentify |
| nuget | https://www.nuget.org/packages/Fluentify/ |
| link | https://github.com/MooVC/fluentify |
| author | Paul Martins |
Generate fluent builder
This is how you can use Fluentify .
The code that you start with is
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
</PropertyGroup>
<PropertyGroup>
<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
<CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\GX</CompilerGeneratedFilesOutputPath>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Fluentify" Version="1.1.0">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
</ItemGroup>
</Project>
The code that you will use is
using Builder;
var pOld = new Person();
pOld= pOld.WithFirstName("Andrei").WithLastName("Ignat").WithMiddleName("G");
System.Console.WriteLine(pOld.FullName());
namespace Builder;
[Fluentify.Fluentify]
public partial class Person
{
public string FirstName { get; init; }
public string? MiddleName { get; init; }
public string LastName { get; init; }
public string FullName()
{
return FirstName + " " + MiddleName + " "+LastName;
}
}
The code that is generated is
#if NET5_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
#nullable enable
#endif
#pragma warning disable CS8625
namespace Builder
{
using System;
using System.Collections.Generic;
using System.Linq;
using Fluentify.Internal;
public static partial class PersonExtensions
{
public static global::Builder.Person WithFirstName(
this global::Builder.Person subject,
string value)
{
subject.ThrowIfNull("subject");
return new global::Builder.Person
{
FirstName = value,
MiddleName = subject.MiddleName,
LastName = subject.LastName,
};
}
}
}
#pragma warning restore CS8625
#if NET5_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
#nullable restore
#endif
#if NET5_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
#nullable enable
#endif
#pragma warning disable CS8625
namespace Builder
{
using System;
using System.Collections.Generic;
using System.Linq;
using Fluentify.Internal;
public static partial class PersonExtensions
{
public static global::Builder.Person WithLastName(
this global::Builder.Person subject,
string value)
{
subject.ThrowIfNull("subject");
return new global::Builder.Person
{
FirstName = subject.FirstName,
MiddleName = subject.MiddleName,
LastName = value,
};
}
}
}
#pragma warning restore CS8625
#if NET5_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
#nullable restore
#endif
#if NET5_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
#nullable enable
#endif
#pragma warning disable CS8625
namespace Builder
{
using System;
using System.Collections.Generic;
using System.Linq;
using Fluentify.Internal;
public static partial class PersonExtensions
{
public static global::Builder.Person WithMiddleName(
this global::Builder.Person subject,
string? value)
{
subject.ThrowIfNull("subject");
return new global::Builder.Person
{
FirstName = subject.FirstName,
MiddleName = value,
LastName = subject.LastName,
};
}
}
}
#pragma warning restore CS8625
#if NET5_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
#nullable restore
#endif
namespace Fluentify
{
using System;
using System.Diagnostics.CodeAnalysis;
[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
internal sealed class DescriptorAttribute
: Attribute
{
public DescriptorAttribute(string value)
{
Value = value;
}
public string Value { get; }
}
}
namespace Fluentify
{
using System;
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
internal sealed class FluentifyAttribute
: Attribute
{
}
}
namespace Fluentify
{
using System;
[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
internal sealed class IgnoreAttribute
: Attribute
{
}
}
namespace Fluentify.Internal
{
using System;
internal static class Extensions
{
public static void ThrowIfNull(this object subject, string paramName)
{
if (subject == null)
{
throw new ArgumentNullException(paramName);
}
}
}
}
Code and pdf at
https://ignatandrei.github.io/RSCG_Examples/v2/docs/Fluentify
RSCG – RSCG_ExportDiagram
| name | RSCG_ExportDiagram |
| nuget | https://github.com/ignatandrei/RSCG_ExportDiagram |
| link | RSCG_ExportDiagram |
| author | AndreiIgnat |
Generating diagram for relation classes within referenced project
This is how you can use RSCG_ExportDiagram .
The code that you start with is
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="RSCG_ExportDiagram" Version="2024.810.832" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
</ItemGroup>
<ItemGroup>
<CompilerVisibleProperty Include="RSCG_ExportDiagram_OutputFolder" />
<CompilerVisibleProperty Include="RSCG_ExportDiagram_Exclude" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Person\Person.csproj" />
</ItemGroup>
<PropertyGroup>
<RSCG_ExportDiagram_OutputFolder>obj/GX/</RSCG_ExportDiagram_OutputFolder>
<RSCG_ExportDiagram_Exclude></RSCG_ExportDiagram_Exclude>
</PropertyGroup>
<PropertyGroup>
<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
<CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\GX</CompilerGeneratedFilesOutputPath>
</PropertyGroup>
</Project>
The code that you will use is
using Person;
internal class Program
{
private static void Main(string[] args)
{
PersonData person = new ();
person.Name = "Andrei Ignat";
Console.WriteLine(person.Name);
}
}
namespace Person;
public class PersonData
{
public string Name { get; set; }
public int Age { get; set; }
}
The code that is generated is
//JSONFolder=obj/GX/
//projectDir=D:\gth\RSCG_Examples\v2\rscg_examples\RSCG_ExportDiagram\src\DiagramDemo\DiagramDemoConsole\
//projectName=DiagramDemoConsole
//excludeData=
file class Program_References_1
{
public Program_References_1()
{
// Method Main has following external references
// Person.PersonData..ctor
//Person.PersonData.Name
}
}
Code and pdf at
https://ignatandrei.github.io/RSCG_Examples/v2/docs/RSCG_ExportDiagram
RSCG – ServiceScan.SourceGenerator
| name | ServiceScan.SourceGenerator |
| nuget | https://www.nuget.org/packages/ServiceScan.SourceGenerator/ |
| link | https://github.com/Dreamescaper/ServiceScan.SourceGenerator |
| author | Oleksandr Liakhevych |
Generating service collection / DI registration
This is how you can use ServiceScan.SourceGenerator .
The code that you start with is
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<PropertyGroup>
<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
<CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\GX</CompilerGeneratedFilesOutputPath>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="ServiceScan.SourceGenerator" Version="1.1.2">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
</ItemGroup>
</Project>
The code that you will use is
using InjectDemo;
using Microsoft.Extensions.DependencyInjection;
var sc=new ServiceCollection();
sc.AddMyServices();
var sp=sc.BuildServiceProvider();
var con = sp.GetService(typeof(Database)) as IDatabase;
ArgumentNullException.ThrowIfNull(con);
con.Open();
public static partial class MyServiceProvider
{
[ServiceScan.SourceGenerator.GenerateServiceRegistrations(AssignableTo = typeof(Database),AsSelf =true, Lifetime = ServiceLifetime.Scoped)]
[ServiceScan.SourceGenerator.GenerateServiceRegistrations(AssignableTo = typeof(IDatabase), Lifetime = ServiceLifetime.Scoped)]
public static partial IServiceCollection AddMyServices(this IServiceCollection services)
;
}
namespace InjectDemo;
partial class Database : IDatabase
{
private readonly IDatabase con;
public Database(IDatabase con)
{
this.con = con;
}
public void Open()
{
Console.WriteLine($"open from database");
con.Open();
}
}
namespace InjectDemo;
public partial class DatabaseCon:IDatabase
{
public string? Connection { get; set; }
public void Open()
{
Console.WriteLine("open from database con" );
}
}
The code that is generated is
#nullable enable
using System;
using System.Diagnostics;
using Microsoft.Extensions.DependencyInjection;
namespace ServiceScan.SourceGenerator;
[Conditional("CODE_ANALYSIS")]
[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
internal class GenerateServiceRegistrationsAttribute : Attribute
{
/// <summary>
/// Set the assembly containing the given type as the source of types to register.
/// If not specified, the assembly containing the method with this attribute will be used.
/// </summary>
public Type? FromAssemblyOf { get; set; }
/// <summary>
/// Set the type that the registered types must be assignable to.
/// Types will be registered with this type as the service type,
/// unless <see cref="AsImplementedInterfaces"/> or <see cref="AsSelf"/> is set.
/// </summary>
public Type? AssignableTo { get; set; }
/// <summary>
/// Set the lifetime of the registered services.
/// <see cref="ServiceLifetime.Transient"/> is used if not specified.
/// </summary>
public ServiceLifetime Lifetime { get; set; }
/// <summary>
/// If set to true, types will be registered as implemented interfaces instead of their actual type.
/// </summary>
public bool AsImplementedInterfaces { get; set; }
/// <summary>
/// If set to true, types will be registered with their actual type.
/// It can be combined with <see cref="AsImplementedInterfaces"/>, in that case implemeted interfaces will be
/// "forwarded" to "self" implementation.
/// </summary>
public bool AsSelf { get; set; }
/// <summary>
/// Set this value to filter the types to register by their full name.
/// You can use '*' wildcards.
/// You can also use ',' to separate multiple filters.
/// </summary>
/// <example>Namespace.With.Services.*</example>
/// <example>*Service,*Factory</example>
public string? TypeNameFilter { get; set; }
}
using Microsoft.Extensions.DependencyInjection;
public static partial class MyServiceProvider
{
public static partial IServiceCollection AddMyServices(this IServiceCollection services)
{
return services
.AddScoped<InjectDemo.Database, InjectDemo.Database>()
.AddScoped<InjectDemo.IDatabase, InjectDemo.Database>()
.AddScoped<InjectDemo.IDatabase, InjectDemo.DatabaseCon>();
}
}
Code and pdf at
https://ignatandrei.github.io/RSCG_Examples/v2/docs/ServiceScan.SourceGenerator
RSCG – ThisAssembly.Strings
| name | ThisAssembly.Strings |
| nuget | https://www.nuget.org/packages/ThisAssembly.Strings/ |
| link | https://github.com/devlooped/ThisAssembly |
| author | Daniel Cazzulino |
generating code from resx files
This is how you can use ThisAssembly.Strings .
The code that you start with is
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="ThisAssembly.Strings" Version="1.4.3">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
</ItemGroup>
<ItemGroup>
<Compile Update="Demo.Designer.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>Demo.resx</DependentUpon>
</Compile>
</ItemGroup>
<ItemGroup>
<EmbeddedResource Update="Demo.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Demo.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
<PropertyGroup>
<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
<CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\GX</CompilerGeneratedFilesOutputPath>
</PropertyGroup>
</Project>
The code that you will use is
Console.WriteLine(ThisAssembly.Strings.PersonName("Andrei Ignat"));
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="PersonName" xml:space="preserve">
<value>The person name is {0}</value>
<comment>the person name</comment>
</data>
</root>
The code that is generated is
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// ThisAssembly.Strings: 1.4.3
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Globalization;
partial class ThisAssembly
{
public static partial class Strings
{
/// <summary>
/// the person name
/// </summary>
public static string PersonName(object arg0) => string.Format(CultureInfo.CurrentCulture, Strings.GetResourceManager("StringsDemo.Demo").GetString("PersonName"), arg0);
}
}
using System.Collections.Concurrent;
using System.Resources;
using System.Runtime.CompilerServices;
/// <summary>
/// Provides access to the current assembly information as pure constants,
/// without requiring reflection.
/// </summary>
partial class ThisAssembly
{
/// <summary>
/// Access the strings provided by resource files in the project.
/// </summary>
[CompilerGenerated]
public static partial class Strings
{
static ConcurrentDictionary<string, ResourceManager> resourceManagers = new ConcurrentDictionary<string, ResourceManager>();
static ResourceManager GetResourceManager(string resourceName)
=> resourceManagers.GetOrAdd(resourceName, name => new ResourceManager(name, typeof(Strings).Assembly));
}
}
Code and pdf at
https://ignatandrei.github.io/RSCG_Examples/v2/docs/ThisAssembly.Strings
RSCG – ThisAssembly.Metadata
| name | ThisAssembly.Metadata |
| nuget | https://www.nuget.org/packages/ThisAssembly.Metadata/ |
| link | https://github.com/devlooped/ThisAssembly |
| author | Daniel Cazzulino |
Generating code from assembly metadata
This is how you can use ThisAssembly.Metadata .
The code that you start with is
<Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <OutputType>Exe</OutputType> <TargetFramework>net8.0</TargetFramework> <ImplicitUsings>enable</ImplicitUsings> <Nullable>enable</Nullable> </PropertyGroup> <ItemGroup> <AssemblyMetadata Include="MyName" Value="Andrei" /> </ItemGroup> <ItemGroup> <PackageReference Include="ThisAssembly.Metadata" Version="1.4.3"> <PrivateAssets>all</PrivateAssets> <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> </PackageReference> </ItemGroup> <PropertyGroup> <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles> <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\GX</CompilerGeneratedFilesOutputPath> </PropertyGroup> </Project>
The code that you will use is
[assembly: System.Reflection.AssemblyMetadataAttribute("Name", "Test")] Console.WriteLine(ThisAssembly.Metadata.Name); Console.WriteLine(ThisAssembly.Metadata.MyName);
The code that is generated is
//------------------------------------------------------------------------------ // <auto-generated> // This code was generated by a tool. // // Changes to this file may cause incorrect behavior and will be lost if // the code is regenerated. // </auto-generated> //------------------------------------------------------------------------------ using System.CodeDom.Compiler; using System.Runtime.CompilerServices; /// <summary> /// Provides access to the current assembly information as pure constants, /// without requiring reflection. /// </summary> partial class ThisAssembly { /// <summary> /// Gets the assembly metadata. /// </summary> [GeneratedCode("ThisAssembly.Metadata", "1.4.3")] [CompilerGenerated] public static partial class Metadata { /// <summary>Name = Test</summary> public const string Name = """ Test """; /// <summary>MyName = Andrei</summary> public const string MyName = """ Andrei """; } }
Code and pdf at https://ignatandrei.github.io/RSCG_Examples/v2/docs/ThisAssembly.Metadata