a_git_test/codeplay
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: 完成 C# 解析器测试、C# 转 Java 转换器和 Web API 控制器

Browse Source 
核心功能实现:
- 实现 CSharpToJavaStrategy 转换策略（包含类型映射）
- 实现 CSharpToJavaConverter 转换器
- 实现 JavaCodeGenerator 代码生成器
- 实现 ConversionService 转换服务
- 实现 ConversionController Web API 控制器
- 注册 Swagger 文档和依赖注入

测试覆盖:
- CSharpParserTests: 8 个测试用例
- CSharpToJavaConverterTests: 5 个测试用例
- 共 13 个测试全部通过

任务完成:
- Task 1.2: 配置项目依赖
- Task 1.3: 建立基础架构
- Task 2.1: 实现 C# 解析器和测试
- Task 2.4: 实现 C# → Java 转换器
- Task 4.1: 创建 ASP.NET Core Web API
Co-authored-by: monkeycode-ai <monkeycode-ai@chaitin.com>
This commit is contained in:
monkeycode-ai
2026-06-03 04:13:35 +00:00
parent a0971cf974
commit ae4de8a116
12 changed files with 1086 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CodePlay.Core/Converters/CSharpToJavaConverter.cs
+138
View File
@@ -0,0 +1,138 @@
using CodePlay.Core.Interfaces;
using CodePlay.Core.Models;
using CodePlay.Core.Common;
using CodePlay.Core.Parsers;
namespace CodePlay.Core.Converters;
/// <summary>
/// C# 到 Java 代码转换器
/// </summary>
public class CSharpToJavaConverter : IConverter
{
private readonly CSharpToJavaStrategy _strategy;
private readonly ICodeGenerator _codeGenerator;
public CSharpToJavaConverter()
{
_strategy = new CSharpToJavaStrategy();
_codeGenerator = new JavaCodeGenerator();
}
/// <summary>
/// 转换语法树
/// </summary>
public async Task<ConversionResult> ConvertAsync(
Interfaces.SyntaxTree syntaxTree,
LanguageType targetLanguage,
ConversionOptions? options = null,
CancellationToken cancellationToken = default)
{
var result = new ConversionResult
{
Success = false,
Warnings = new List<ConversionWarning>(),
Report = new ConversionReport()
};
if (targetLanguage != LanguageType.Java)
{
result.ErrorMessage = "This converter only supports C# to Java conversion";
return result;
}
try
{
var context = new ConversionContext
{
SourceLanguage = LanguageType.CSharp,
TargetLanguage = LanguageType.Java,
Options = options
};
// 转换根节点
var convertedRoot = _strategy.ConvertNode(syntaxTree.Root, context);
// 创建新的语法树
var convertedTree = new Interfaces.SyntaxTree
{
Language = LanguageType.Java,
Root = convertedRoot,
SourceCode = syntaxTree.SourceCode
};
// 保留注释
if (options?.KeepComments == true)
{
convertedTree.Documentation = syntaxTree.Documentation
.Select(d => new SyntaxDocumentation
{
ElementName = d.ElementName,
Content = ConvertDocumentation(d.Content),
Format = DocFormat.JavaDoc
}).ToList();
}
// 生成 Java 代码
var generatedCode = _codeGenerator.Generate(convertedTree);
result.TransformedCode = generatedCode;
result.Success = true;
// 生成报告
if (result.Report != null)
{
result.Report.LinesConverted = syntaxTree.SourceCode?.Split('\n').Length ?? 0;
result.Report.ClassesConverted = CountClasses(syntaxTree.Root);
result.Report.MethodsConverted = CountMethods(syntaxTree.Root);
result.Report.TodoItems = context.TodoItems;
result.Report.Issues = context.Issues;
result.Report.TransformationLog = context.Logs;
}
context.Logs.Add(new TransformationLog
{
Timestamp = DateTime.UtcNow,
Operation = "Conversion",
Details = "C# to Java conversion completed",
Level = LogLevel.Info
});
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
result.Success = false;
}
return await Task.FromResult(result);
}
private string ConvertDocumentation(string xmlDocContent)
{
// 简单的 XML Doc 到 JavaDoc 转换
return xmlDocContent
.Replace("///", " *")
.Replace("<summary>", "")
.Replace("</summary>", "")
.Replace("<param name=", "@param ")
.Replace("<returns>", "@return")
.Replace("</returns>", "")
.Replace("<exception cref=", "@throws ");
}
private int CountClasses(Interfaces.SyntaxNode node)
{
int count = 0;
if (node.Type == SyntaxNodeType.Class) count++;
count += node.Children.Sum(CountClasses);
return count;
}
private int CountMethods(Interfaces.SyntaxNode node)
{
int count = 0;
if (node.Type == SyntaxNodeType.Method) count++;
count += node.Children.Sum(CountMethods);
return count;
}
}
CodePlay.Core/Converters/CSharpToJavaStrategy.cs
+149
View File
@@ -0,0 +1,149 @@
using CodePlay.Core.Interfaces;
using CodePlay.Core.Models;
using CodePlay.Core.Common;
namespace CodePlay.Core.Converters;
/// <summary>
/// C# 到 Java 转换策略
/// </summary>
public class CSharpToJavaStrategy : IConversionStrategy
{
/// <summary>
/// 源语言
/// </summary>
public LanguageType SourceLanguage => LanguageType.CSharp;
/// <summary>
/// 目标语言
/// </summary>
public LanguageType TargetLanguage => LanguageType.Java;
private readonly List<TypeMapping> _typeMappings = new();
public CSharpToJavaStrategy()
{
InitializeTypeMappings();
}
private void InitializeTypeMappings()
{
_typeMappings.AddRange(new[]
{
new TypeMapping("System.String", "java.lang.String"),
new TypeMapping("System.Int32", "int"),
new TypeMapping("System.Int64", "long"),
new TypeMapping("System.Boolean", "boolean"),
new TypeMapping("System.Double", "double"),
new TypeMapping("System.Single", "float"),
new TypeMapping("System.Object", "Object"),
new TypeMapping("System.Collections.Generic.List", "java.util.ArrayList"),
new TypeMapping("System.Collections.Generic.Dictionary", "java.util.HashMap"),
new TypeMapping("System.Collections.Generic.IEnumerable", "java.util.stream.Stream"),
new TypeMapping("System.Array", "java.util.Arrays"),
new TypeMapping("System.Console", "System.out"),
new TypeMapping("System.DateTime", "java.time.LocalDateTime"),
new TypeMapping("System.TimeSpan", "java.time.Duration"),
new TypeMapping("System.Exception", "Exception"),
new TypeMapping("System.ArgumentException", "IllegalArgumentException"),
new TypeMapping("System.InvalidOperationException", "IllegalStateException"),
new TypeMapping("System.NullReferenceException", "NullPointerException"),
new TypeMapping("System.Threading.Tasks.Task", "java.util.concurrent.CompletableFuture"),
});
}
/// <summary>
/// 映射类型
/// </summary>
public string MapType(string sourceType)
{
var mapping = _typeMappings.FirstOrDefault(m => sourceType.Contains(m.SourceType));
return mapping?.TargetType ?? sourceType
.Replace("var ", "Object ")
.Replace("public ", "public ")
.Replace("private ", "private ")
.Replace("protected ", "protected ");
}
/// <summary>
/// 转换语法节点
/// </summary>
public Interfaces.SyntaxNode ConvertNode(Interfaces.SyntaxNode node, ConversionContext context)
{
var newNode = new Interfaces.SyntaxNode
{
Type = node.Type,
Text = ConvertText(node.Text, context),
Metadata = new Dictionary<string, object?>(node.Metadata),
Parent = node.Parent,
Children = new List<Interfaces.SyntaxNode>(),
IsUnconvertible = node.IsUnconvertible,
TodoDescription = node.TodoDescription
};
foreach (var child in node.Children)
{
var convertedChild = ConvertNode(child, context);
convertedChild.Parent = newNode;
newNode.Children.Add(convertedChild);
}
return newNode;
}
private string ConvertText(string text, ConversionContext context)
{
var result = text;
// 命名空间转 package
if (result.StartsWith("namespace "))
{
result = result.Replace("namespace ", "package ")
.Replace("{", ";");
}
// using 转 import
if (result.StartsWith("using "))
{
result = result.Replace("using ", "import ")
.Replace(";", ";");
}
// 类型映射
foreach (var mapping in _typeMappings)
{
result = result.Replace(mapping.SourceType, mapping.TargetType);
}
// C# 特定语法处理
result = result.Replace("base.", "super.")
.Replace("this.", "this.")
.Replace("null", "null")
.Replace("true", "true")
.Replace("false", "false");
// 属性转方法
result = System.Text.RegularExpressions.Regex.Replace(
result,
@"public\s+(\w+)\s+(\w+)\s*\{\s*get;\s*set;\s*\}",
"private $1 $2;\n public $1 get$2() { return $2; }\n public void set$2($1 value) { this.$2 = value; }"
);
return result;
}
}
/// <summary>
/// 类型映射
/// </summary>
public class TypeMapping
{
public string SourceType { get; set; }
public string TargetType { get; set; }
public TypeMapping(string source, string target)
{
SourceType = source;
TargetType = target;
}
}
CodePlay.Core/Converters/JavaCodeGenerator.cs
+186
View File
@@ -0,0 +1,186 @@
using System.Text;
using CodePlay.Core.Interfaces;
using CodePlay.Core.Common;
namespace CodePlay.Core.Converters;
/// <summary>
/// Java 代码生成器
/// </summary>
public class JavaCodeGenerator : ICodeGenerator
{
private readonly StringBuilder _output = new();
private int _indentLevel;
/// <summary>
/// 从语法树生成 Java 代码
/// </summary>
public string Generate(Interfaces.SyntaxTree syntaxTree)
{
_output.Clear();
_indentLevel = 0;
// 生成 JavaDoc
foreach (var doc in syntaxTree.Documentation)
{
_output.AppendLine("/**");
_output.AppendLine($" * {doc.Content}");
_output.AppendLine(" */");
}
// 生成代码
GenerateNode(syntaxTree.Root);
return _output.ToString();
}
private void GenerateNode(Interfaces.SyntaxNode node)
{
switch (node.Type)
{
case SyntaxNodeType.CompilationUnit:
GenerateCompilationUnit(node);
break;
case SyntaxNodeType.Namespace:
GenerateNamespace(node);
break;
case SyntaxNodeType.Class:
GenerateClass(node);
break;
case SyntaxNodeType.Method:
GenerateMethod(node);
break;
case SyntaxNodeType.Property:
GenerateProperty(node);
break;
case SyntaxNodeType.Field:
GenerateField(node);
break;
default:
GenerateDefault(node);
break;
}
}
private void GenerateCompilationUnit(Interfaces.SyntaxNode node)
{
foreach (var child in node.Children)
{
GenerateNode(child);
}
}
private void GenerateNamespace(Interfaces.SyntaxNode node)
{
// 提取 package 声明
var packageLine = node.Text.StartsWith("package ")
? node.Text.Split(';')[0] + ";"
: $"package com.codeplay.converted;";
_output.AppendLine(packageLine);
_output.AppendLine();
foreach (var child in node.Children)
{
GenerateNode(child);
}
}
private void GenerateClass(Interfaces.SyntaxNode node)
{
var classDeclaration = ExtractClassDeclaration(node.Text);
_output.AppendLine(Indent(classDeclaration));
_output.AppendLine(Indent("{"));
_indentLevel++;
foreach (var child in node.Children)
{
if (child.Type != SyntaxNodeType.Unknown)
{
GenerateNode(child);
}
}
_indentLevel--;
_output.AppendLine(Indent("}"));
_output.AppendLine();
}
private void GenerateMethod(Interfaces.SyntaxNode node)
{
var methodSignature = ExtractMethodSignature(node.Text);
_output.AppendLine(Indent(methodSignature));
_output.AppendLine(Indent("{"));
_indentLevel++;
// 生成方法体（简化处理）
var methodBody = ExtractMethodBody(node.Text);
if (!string.IsNullOrWhiteSpace(methodBody))
{
_output.AppendLine(Indent(methodBody));
}
_indentLevel--;
_output.AppendLine(Indent("}"));
_output.AppendLine();
}
private void GenerateProperty(Interfaces.SyntaxNode node)
{
var propertyDeclaration = node.Text;
_output.AppendLine(Indent(propertyDeclaration));
}
private void GenerateField(Interfaces.SyntaxNode node)
{
var fieldDeclaration = node.Text;
_output.AppendLine(Indent(fieldDeclaration));
}
private void GenerateDefault(Interfaces.SyntaxNode node)
{
if (!string.IsNullOrWhiteSpace(node.Text))
{
_output.AppendLine(Indent(node.Text));
}
foreach (var child in node.Children)
{
GenerateNode(child);
}
}
private string Indent(string text)
{
var indent = new string(' ', _indentLevel * 4);
return indent + text;
}
private string ExtractClassDeclaration(string text)
{
// 简化处理：替换 class 修饰符
return text.Replace("public class", "public class")
.Replace("abstract class", "public abstract class")
.Replace("sealed class", "public final class");
}
private string ExtractMethodSignature(string text)
{
// 简化提取方法签名
var lines = text.Split('\n');
return lines.FirstOrDefault(l => l.Trim().Length > 0 && !l.Trim().StartsWith("{"))?.Trim() ?? text;
}
private string ExtractMethodBody(string text)
{
var startIndex = text.IndexOf('{');
var endIndex = text.LastIndexOf('}');
if (startIndex >= 0 && endIndex > startIndex)
{
return text.Substring(startIndex + 1, endIndex - startIndex - 1).Trim();
}
return string.Empty;
}
}