DynatestSourceGenerator 0.0.4.5

Dynatest Source Generator

Dynatest Source Generator is a package that generates source code based on attributes added to your C# code. This package can help automate the creation of Data Transfer Objects (DTOs) or other code structures by generating code from attributes.

Installation

You can install Dynatest Source Generator using the following command in the Package Manager Console:

Install-Package DynatestSourceGenerator

Or, you can install it using the .NET CLI:

dotnet add package DynatestSourceGenerator

Usage

To use Dynatest Source Generator, you need to add the [GenerateDto] attribute to the classes that you want to generate code for. The attribute takes optional arguments to specify the name of the generated class. For example:

[GenerateDto]
public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
}

The above code will generate a new class called PersonDTO that has the same properties as the Person class.

public class PersonDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    
    public PersonDto MapFrom(Person instance)
    {
	Id = instance.Id;
	Name = instance.Name;
	return this;
    }

    public Person MapTo()
    {
	   return new Person
       {
          Id = Id,
          Name = Name,
       };
    }
}

Excluding Properties

You can exclude properties from the generated class by adding the [ExcludeProperty] attribute to the properties that you want to exclude. For example:

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    
    [ExcludeProperty]
    public DateTime BirthDate { get; set; }
}

The above code will exclude the BirthDate property from the generated class.

public class PersonDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    
    public PersonDto MapFrom(Person instance)
    {
	Id = instance.Id;
	Name = instance.Name;
	return this;
    }

    public Person MapTo()
    {
	   return new Person
       {
          Id = Id,
          Name = Name,
       };
    }
}

Using existing DTO

One can utilize an already generated DTO from a different class by applying the [UseExistingDto] attribute to the respective property, thus indicating the preference to use the existing DTO version. It is important to note that this approach is only applicable to classes that already have a DTO version generated. An illustrative instance is provided below for better comprehension:

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    [UseExistingDto]
    public Country Country {get; set; }
    public DateTime BirthDate { get; set; }
}

The above code will use the DTO version of Country in the generated class.

public class PersonDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public CountryDto Country {get; set; }
    public DateTime BirthDate { get; set; }
    
    public PersonDto MapFrom(Person instance)
    {
        Id = instance.Id;
        Name = instance.Name;
        Country = new CountryDTO().MapFrom(instance.Country);
        BirthDate = instance.BirthDate;
        return this;
    }

    public Person MapTo(Person instance)
    {
        return new Person
        {
           Id = Id,
           Name = Name,
           Country = Country.MapTo();
           BirthDate = BirthDate,
        };
    }
}

One can also use a customized name for the DTO, which will be utilized instead of the default name "DTO".

    [UseExistingDto("CountryB")]
    public Country Country {get; set; }

The above code will generate CountryB instead of CountryDTO.

    public CountryB Country {get; set; }

Attributes

Using the Generated Class

To use the MapFrom method, you first need to create an instance of the original class:

var person = new Person { Id = 1, Name = "John", BirthDate = new DateTime(1980, 1, 1) };

Then, you can create an instance of the generated class and call its MapFrom method to map the properties from the original class to the generated class:

var personDto = new PersonDTO().MapFrom(person);

To use the MapTo method, you can create an instance of the generated class and call its MapTo method to map the properties from the generated class to the original class:

Person person = new PersonDTO(){ Id = 1, Name = "John", BirthDate = new DateTime(1980, 1, 1) }.MapTo();

Advanced Usage

One has the alternative to produce numerous Data Transfer Objects (DTOs) simultaneously, a task that can be accomplished with ease by including parentheses and appending parameter strings, as demonstrated in the following instance:

[GenerateDto("StationDTO", "StationWithOnlyLevelDTO")]
public class Station
{
    [ExcludeProperty("StationWithOnlyLevelDTO")]
    public string Name { get; set; }
    public int Level { get; set; }
    [ExcludeProperty("StationWithOnlyLevelDTO")]
    public string Owner { get; set; }
    [UseExistingDTO("StationDTO > WeatherForecastDTO")]
    public WeatherForecast Forecasts { get; set; }
}

The code presented below displays the resulting classes, revealing that StationWithOnlyLevelDTO solely encompasses a Level property, whereas StationDTO comprehends all properties derived from the Station class.

public class StationDTO
{
    [ExcludeProperty("StationWithOnlyLevelDTO")] 
    public string Name { get; set; }
    public int Level { get; set; }
    [ExcludeProperty("StationWithOnlyLevelDTO")]
    public string Owner { get; set; }
    public WeatherForecastDTO Forecasts { get; set; }

    public StationDTO MapFrom(Station instance)
    {
	    Name = instance.Name;
	    Level = instance.Level;
	    Owner = instance.Owner;
	    return this;
    }

    public Station MapTo()
    {
       return new Station
       {
	      Name = Name,
	      Level = Level,
	      Owner = Owner,
       };
    }
}

public class StationWithOnlyLevelDTO
{
    public int Level { get; set; }

    public StationWithNoNameDTO MapFrom(Station instance)
    {
        Level = instance.Level;
        return this;
    }
    public StationWithNoNameDTO MapTo()
    {
       return new Station
       {
          Level = Level,
       };
    }
}

Limitations

Currently, the source generator does not provide any error messages when performing unlawful actions such as using UseExistingDto for a string. However, this feature will be included in upcoming updates. Furthermore, if UseExistingDto is utilized as a key-value pair for a Dictionary, the source generator is incapable of handling it.

Version

Current version: 0.4.3