public List <GeneratedFile> GenerateCode(CodeGenerationConfig outputConfig)
{
var generator = new LiquidTemplateGenerator(_TemplatePath);
var relativeNamespace = NamespaceHelper.GetNamespaceFromPath(FilePath);
var fileObjectNamespace = NamespaceHelper.GetNamespaceFromFullTypeName(FileObjectType);
var fileObjectTypeName = NamespaceHelper.GetTypeFromFullTypeName(FileObjectType);
var fileContents = generator.Render(new
{
Namespace = outputConfig.ProjectRootNamespace + "." + relativeNamespace,
ClassName = ClassName,
FileName = FileName,
FileObjectType = fileObjectTypeName,
FileObjectName = fileObjectTypeName,
FileObjectNamespace = fileObjectNamespace,
});
var filePath = Path.Combine(outputConfig.CSharpRootPath, FilePath);
return(new List <GeneratedFile>()
{
new GeneratedFile()
{
Path = $"{filePath}/{ClassName}.cs",
Contents = fileContents
}
});
}
public void Execute(SourceGeneratorContext context)
{
_config = ConfigParser.GetConfig(_visitor, context);
if (!string.IsNullOrEmpty(_config.Debugging?.LogOutput))
{
_logger.RegisterFactory(
new FileLogOutputFactory("Log Output",
_config.Debugging.LogOutput,
LogScope.Error | LogScope.Warning | LogScope.Information,
LogScope.Objects,
DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss"))
);
}
if (string.IsNullOrEmpty(_config.Debugging?.ObjectOutput))
{
_logger.RegisterFactory(
new FileLogOutputFactory("Object Output",
_config.Debugging?.ObjectOutput,
LogScope.Error | LogScope.Warning | LogScope.Information,
LogScope.Objects,
DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss"))
);
}
if (_config?.Builders == null)
{
_logger.LogError("Skipping generation", "No template config found.", null);
}
_generationEngine.NewGeneration();
GenerateCode(context);
}
public void Register(CodeGenerationConfig config)
{
config.AdaptTo("[name]Dto", MapType.Map | MapType.MapToTarget | MapType.Projection)
.ApplyDefaultRule()
.AlterType <Student, Person>();
config.AdaptFrom("[name]Add", MapType.Map)
.ApplyDefaultRule()
.IgnoreNoModifyProperties();
config.AdaptFrom("[name]Update", MapType.MapToTarget)
.ApplyDefaultRule()
.IgnoreAttributes(typeof(KeyAttribute))
.IgnoreNoModifyProperties();
config.AdaptFrom("[name]Merge", MapType.MapToTarget)
.ApplyDefaultRule()
.IgnoreAttributes(typeof(KeyAttribute))
.IgnoreNoModifyProperties()
.IgnoreNullValues(true);
config.GenerateMapper("[name]Mapper")
.ForType <Course>()
.ForType <Student>();
}
private static void GenerateModels(ModelOptions opt)
{
using var dynamicContext = new AssemblyResolver(Path.GetFullPath(opt.Assembly));
var assembly = dynamicContext.Assembly;
var codeGenConfig = new CodeGenerationConfig();
codeGenConfig.Scan(assembly);
var types = assembly.GetTypes().ToHashSet();
foreach (var builder in codeGenConfig.AdaptAttributeBuilders)
{
foreach (var setting in builder.TypeSettings)
{
types.Add(setting.Key);
}
}
foreach (var type in types)
{
var builders = type.GetAdaptAttributeBuilders(codeGenConfig)
.Where(it => !string.IsNullOrEmpty(it.Attribute.Name) && it.Attribute.Name != "[name]")
.ToList();
if (builders.Count == 0)
{
continue;
}
Console.WriteLine($"Processing: {type.FullName}");
foreach (var builder in builders)
{
CreateModel(opt, type, builder);
}
}
}
public void Register(CodeGenerationConfig config)
{
//config.AdaptTo("[name]Dto")
// .ForType<Student>(builder =>
// builder.Settings[nameof(Student.FirstMidName)].TargetPropertyType = typeof(string?));
//config.AdaptFrom("[name]Merge")
// .ForType<Student>()
// .IgnoreNullValues(true);
//config.AdaptTo("[name]Dto").ForType<Enrollment>().MapToConstructor(true);
//config.AdaptFrom("[name]Dto").ForType<Enrollment>();
config.AdaptTo("[name]Dto", MapType.Map | MapType.MapToTarget | MapType.Projection)
.ForAllTypesInNamespace(Assembly.GetExecutingAssembly(), "MapsterTest.Domains")
.MapToConstructor(true)
.ShallowCopyForSameType(true) //浅拷贝
.ExcludeTypes(o => o.IsEnum || Nullable.GetUnderlyingType(o)?.IsEnum == true)
.MaxDepth(3) //嵌套深度
.PreserveReference(true) //缓存 dto 对象
//.ForType<Student>(builder => builder.IsNullableReference(o => o.FirstMidName))
;
config.GenerateMapper("[name]Mapper")
.ForAllTypesInNamespace(Assembly.GetExecutingAssembly(), "MapsterTest.Domains")
;
}
protected void SaveCodeGenerationConfig(bool isInit = false)
{
try
{
XmlSerializer serializer = new XmlSerializer(typeof(CodeGenerationConfig));
if (isInit)
{
_config = new CodeGenerationConfig();
}
else
{
Dictionary <string, string> metadata = ServiceMetadata;
_config = new CodeGenerationConfig()
{
LatestServiceState = TargetServiceState,
LatestUsedDomain = metadata[ServiceDomainKey],
LatestUsedServiceName = metadata[ServiceNameKey],
LatestUsedServiceNamespance = metadata[ServiceNamespaceKey],
LatestUsedServiceDescription = metadata[ServiceDocumentationKey]
};
}
_config.RepositryRegisteredServiceInterfaceUrl = RepositryRegisteredServiceInterfaceUrl;
using (StreamWriter writer = new StreamWriter(ConfigFilePath))
{
serializer.Serialize(writer, _config);
}
}
catch (Exception ex)
{
Logger.WriteLine("Error: [SaveCodeGenerationConfig] {0}", ex);
}
}
protected void LoadCodeGenerationConfig()
{
if (File.Exists(ConfigFilePath))
{
try
{
XmlSerializer serializer = new XmlSerializer(typeof(CodeGenerationConfig));
using (StreamReader reader = new StreamReader(ConfigFilePath))
{
_config = (CodeGenerationConfig)serializer.Deserialize(reader);
RepositryRegisteredServiceInterfaceUrl = _config.RepositryRegisteredServiceInterfaceUrl;
urlText.Text = RepositryRegisteredServiceInterfaceUrl;
}
}
catch (Exception ex)
{
Logger.WriteLine("Error: [LoadCodeGenerationConfig] {0}", ex);
}
}
else
{
SaveCodeGenerationConfig(true);
}
if (_config == null)
{
_config = new CodeGenerationConfig();
}
}
public void Register(CodeGenerationConfig config)
{
config.AdaptTo("[name]ResultDto", MapType.Map | MapType.MapToTarget | MapType.Projection)
.ApplyDefaultRule();
config.AdaptFrom("[name]Dto", MapType.Map)
.ApplyDefaultRule();
}
public static CodeGenerationConfig GetConfig(SourceFileSymbolVisitor visitor, SourceGeneratorContext context)
{
string file = File.ReadAllText("codegen.json");
CodeGenerationConfig config = JSON.Parse <CodeGenerationConfig>(file);
if (config != null)
{
}
return(config);
}
public void Register(CodeGenerationConfig config)
{
var as1 = Assembly.Load("SeparateProject");
config.AdaptTo("[name]Dto")
.ForAllTypesInNamespace(as1, "SeparateProject.Models");
config.GenerateMapper("[name]Mapper")
.ForAllTypesInNamespace(as1, "SeparateProject.Models");
}
public void Register(CodeGenerationConfig config)
{
config.AdaptTo("[name]Dto", MapType.Map | MapType.MapToTarget | MapType.Projection)
.ApplyDefaultRule();
config.GenerateMapper("[name]Mapper")
.ForType <Product>()
.ForType <Customer>()
.ForType <Country>();
}
public void Register(CodeGenerationConfig config)
{
config.AdaptTwoWays("[name]DTO", MapType.Map | MapType.MapToTarget | MapType.Projection)
.ApplyDefaultRule();
config.AdaptTwoWays("[name]DTO", MapType.Map | MapType.MapToTarget | MapType.Projection)
.ForType <User>().IgnoreNoAttributes(typeof(DataMemberAttribute));
config.GenerateMapper("[name]Mapper")
.ForAllTypesInNamespace(Assembly.GetAssembly(typeof(BaseEntity)), "DAL.Entities");
}
public static void Scan(this CodeGenerationConfig config, Assembly assembly)
{
var registers = assembly.GetTypes()
.Where(x => typeof(ICodeGenerationRegister).GetTypeInfo().IsAssignableFrom(x.GetTypeInfo()) &&
x.GetTypeInfo().IsClass&& !x.GetTypeInfo().IsAbstract)
.Select(type => (ICodeGenerationRegister)Activator.CreateInstance(type) !);
foreach (var register in registers)
{
register.Register(config);
}
}
public static IEnumerable <GenerateMapperAttribute> GetGenerateMapperAttributes(this Type type, CodeGenerationConfig config)
{
foreach (var attribute in type.SafeGetCustomAttributes())
{
if (attribute is GenerateMapperAttribute genMapperAttr)
{
yield return(genMapperAttr);
}
}
foreach (var builder in config.GenerateMapperAttributeBuilders)
{
if (builder.Types.Contains(type))
{
yield return(builder.Attribute);
}
}
}
public static IEnumerable <AdaptAttributeBuilder> GetAdaptAttributeBuilders(this Type type, CodeGenerationConfig config)
{
foreach (var attribute in type.SafeGetCustomAttributes())
{
if (attribute is BaseAdaptAttribute adaptAttr)
{
yield return(new AdaptAttributeBuilder(adaptAttr));
}
}
foreach (var builder in config.AdaptAttributeBuilders)
{
if (builder.TypeSettings.ContainsKey(type))
{
yield return(builder);
}
}
}
public void Register(CodeGenerationConfig config)
{
config.AdaptTo("[name]Dto")
.ForAllTypesInNamespace(Assembly.GetExecutingAssembly(), "Kasp.ObjectMapper.Benchmark.Models");
}
