3

Controllers/FortranController.cs

@@ -0,0 +1,74 @@
+using Microsoft.AspNetCore.Mvc;
+using FortranWebApi.Models;
+using FortranWebApi.Services;
+using System.Text.Json;
+
+namespace FortranWebApi.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class FortranCalculateController : ControllerBase
+    {
+        private readonly FortranInteropService _fortranService;
+        private readonly ILogger<FortranCalculateController> _logger;
+
+        public FortranCalculateController(FortranInteropService fortranService, ILogger<FortranCalculateController> logger)
+        {
+            _fortranService = fortranService;
+            _logger = logger;
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] FortranRequestWrapper wrapper)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(wrapper.Text))
+                {
+                    return BadRequest(new
+                    {
+                        message = "请求文本不能为空",
+                        success = false,
+                        data = (object)null
+                    });
+                }
+
+                string result = _fortranService.ProcessFortranRequest(wrapper.Text);
+                
+                // 使用驼峰命名法解析结果
+                var options = new JsonSerializerOptions
+                {
+                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+                    DictionaryKeyPolicy = JsonNamingPolicy.CamelCase,
+                    PropertyNameCaseInsensitive = true,
+                    WriteIndented = true
+                };
+                
+                var resultObj = JsonSerializer.Deserialize<FortranRequest>(result, options);
+                
+                // 返回新的格式
+                var response = new ApiResponse<FortranRequest>
+                {
+                    Message = "Success",
+                    Success = true,
+                    Data = new ApiResponseData<FortranRequest>
+                    {
+                        Value = resultObj
+                    }
+                };
+
+                return Ok(response);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "处理Fortran请求时发生错误");
+                return StatusCode(500, new
+                {
+                    message = ex.Message,
+                    success = false,
+                    data = (object)null
+                });
+            }
+        }
+    }
+} 

Dockerfile

@@ -0,0 +1,88 @@
+# ===== 第一阶段：构建阶段 =====
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+
+# 配置 NuGet 使用国内镜像源
+RUN dotnet nuget add source https://mirrors.cloud.tencent.com/nuget/ \
+    && dotnet nuget disable source nuget.org
+
+# 配置 apt-get 使用 apt-cacher-ng 作为代理
+RUN echo 'Acquire::http::Proxy "http://192.168.1.140:3142";' > /etc/apt/apt.conf.d/01proxy
+
+# 创建并配置 Debian 镜像源
+RUN echo "deb https://mirrors.ustc.edu.cn/debian/ bookworm main contrib non-free non-free-firmware" > /etc/apt/sources.list && \
+    echo "deb https://mirrors.ustc.edu.cn/debian/ bookworm-updates main contrib non-free non-free-firmware" >> /etc/apt/sources.list && \
+    echo "deb https://mirrors.ustc.edu.cn/debian-security bookworm-security main contrib non-free non-free-firmware" >> /etc/apt/sources.list
+
+# 允许使用不安全的软件源
+RUN echo 'Acquire::AllowInsecureRepositories "true";' > /etc/apt/apt.conf.d/99allow-insecure && \
+    echo 'Acquire::AllowDowngradeToInsecureRepositories "true";' >> /etc/apt/apt.conf.d/99allow-insecure
+
+WORKDIR /src
+
+# 安装 Fortran 编译器
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gfortran \
+    && rm -rf /var/lib/apt/lists/*
+
+# 复制 Fortran 源文件并编译
+COPY Fortran/*.f90 /src/Fortran/
+WORKDIR /src/Fortran
+
+# 编译所有 .f90 文件为 .o 文件
+RUN for file in *.f90; do gfortran -fPIC -c "$file" -o "${file%.f90}.o"; done
+
+# 链接所有 .o 文件为共享库
+RUN gfortran -shared *.o -o libSUB_UNITHYDRO.so
+
+# 回到主工作目录
+WORKDIR /src
+
+# 只复制项目文件
+COPY ["FortranWebApi.csproj", "./"]
+RUN dotnet restore
+
+# 复制源代码
+COPY . .
+
+# 合并 build 和 publish 命令
+RUN dotnet publish -c Release -o /app/publish
+
+# 复制编译好的 .so 文件到发布目录
+RUN mkdir -p /app/publish && \
+    cp /src/Fortran/libSUB_UNITHYDRO.so /app/publish/
+
+# ===== 第二阶段：运行阶段 =====
+FROM mcr.microsoft.com/dotnet/aspnet:8.0
+
+# 配置 apt-get 使用 apt-cacher-ng 作为代理
+RUN echo 'Acquire::http::Proxy "http://192.168.1.140:3142";' > /etc/apt/apt.conf.d/01proxy
+
+# 创建并配置 Debian 镜像源
+RUN echo "deb https://mirrors.ustc.edu.cn/debian/ bookworm main contrib non-free non-free-firmware" > /etc/apt/sources.list && \
+    echo "deb https://mirrors.ustc.edu.cn/debian/ bookworm-updates main contrib non-free non-free-firmware" >> /etc/apt/sources.list && \
+    echo "deb https://mirrors.ustc.edu.cn/debian-security bookworm-security main contrib non-free non-free-firmware" >> /etc/apt/sources.list
+
+# 允许使用不安全的软件源
+RUN echo 'Acquire::AllowInsecureRepositories "true";' > /etc/apt/apt.conf.d/99allow-insecure && \
+    echo 'Acquire::AllowDowngradeToInsecureRepositories "true";' >> /etc/apt/apt.conf.d/99allow-insecure
+
+# 安装运行时依赖
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libc6-dev \
+    libgfortran5 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY --from=build /app/publish .
+
+# 确保 .so 文件的权限正确
+RUN chmod 755 /app/libSUB_UNITHYDRO.so
+
+# 设置 LD_LIBRARY_PATH
+ENV LD_LIBRARY_PATH=/app
+
+# 设置端口和监听地址
+ENV ASPNETCORE_URLS=http://+:5000
+EXPOSE 5000
+
+ENTRYPOINT ["dotnet", "FortranWebApi.dll"] 

Fortran/SUB_UNITHYDRO.f90

@@ -0,0 +1,113 @@
+
+    !根据流域经验单位线和实测的降雨量，推求净雨过程和洪水过程线
+
+    SUBROUTINE SUB_UNITHYDRO(S,&          !流域面积                 浮点数，输入
+                            QT,&         !暴雨过程降雨量           浮点数，输入
+                            M,&          !暴雨过程时段数             整数，输入
+                            Q,&          !该流域典型单位线         浮点数，输入
+                            N,&          !单位线时段数               整数，输入
+                            IM,&         !最大蓄水量               浮点数，输入
+                            FC,&         !稳定下渗率               浮点数，输入
+                            QF,&         !基流                     浮点数，输入
+                            T,&          !每时段的时长             浮点数，输入
+                            A,&          !地下与地面径流历时的比值 浮点数，输入
+                            RUNOFF_U,&   !地面径流过程线           浮点数，输出
+                            RUNOFF_G,&   !地下径流过程线           浮点数，输出
+                            RUNOFF)&      !总的洪水过程线           浮点数，输出
+    bind(C, name="SUB_UNITHYDRO")
+    !DEC$ ATTRIBUTES DLLEXPORT::SUB_UNITHYDRO
+    integer :: m,n
+    real :: S,Qt(m),q(n),Im,fc,Qf,t,a
+    real :: Qsum(m),Qj_sum(m),Qj_t(m),Qj_g(m),Qj_u(m)
+    real :: runoff_ut(100,100),runoff_u(100),runoff_g(100),W(100)
+    integer :: x,y
+    real :: Wg,Tg,Qmg
+    real :: Pa                              !前期影响雨量
+    real :: Qj_eu(100)                      !把地面净雨量大于0的单独存入
+    real :: Qj_gs=0                         !地下净雨总量
+    integer :: i,j                          !计数器
+    
+    !**************    净雨计算及净雨的分割   **************
+    
+    !计算累计降雨量
+    Qsum(1)=Qt(1)
+    do i=2,m
+        Qsum(i)=Qsum(i-1)+Qt(i)
+    end do 
+    
+    !计算各净雨量
+    Pa=Im*2/3
+    do i=1,m
+        if(Qsum(i)<=(Im-Pa)) then
+            Qj_t(i)=0
+            Qj_g(i)=0
+        else
+            Qj_t(i)=Qsum(i)-(Im-Pa)
+            Qj_g(i)=(Qj_t(i)/Qt(i))*t*fc
+            exit
+        end if
+    end do
+    do while(i<m)
+        Qj_t(i+1)=Qt(i+1)                           !时段净雨量
+        Qj_g(i+1)=t*fc
+        if(Qj_g(i+1)>Qt(i+1)) Qj_g(i+1)=Qt(i+1)     !地下净雨量
+        i=i+1
+    end do
+    Qj_sum(1)=Qj_t(1)
+    Qj_u(1)=Qj_t(1)-Qj_g(1)
+    do i=2,m
+        Qj_sum(i)=Qj_sum(i-1)+Qj_t(i)               !累计净雨量
+        Qj_u(i)=Qj_t(i)-Qj_g(i)                     !地面净雨量
+    end do
+    
+    !********************      推求洪水过程线    **************************
+    
+    !计算地面径流过程*************************************
+    
+    x=0
+    do i=1,m
+        if(Qj_u(i)/=0) then
+            x=x+1
+            Qj_eu(x)=Qj_u(i)
+        end if
+    end do
+    runoff_ut=0
+    runoff_u=0
+    y=n+x
+    
+    !单位线法计算各时段地面径流过程
+    do i=1,n
+        do j=1,x
+            runoff_ut(j,i+j-1)=q(i)*Qj_eu(j)/10.0
+        end do
+    end do
+    
+    !计算地面径流过程线
+    do i=1,y
+        do j=1,x
+        runoff_u(i)=runoff_u(i)+runoff_ut(j,i)
+        end do
+    end do
+    
+    !计算地下径流过程*********************************
+    runoff_g(1)=0
+    do i=1,m
+        Qj_gs=Qj_gs+Qj_g(i)
+    end do
+    Wg=1000*Qj_gs*S
+    Tg=a*(y-2)*t
+    Qmg=2*Wg/(Tg*3600)        
+    
+    do i=2,y
+        runoff_g(i)=runoff_g(i-1)+Qmg/(a*(y-2)/2)
+        if(i>(a*(y-2)/2+1)) runoff_g(i)=runoff_g(i-1)-Qmg/(a*(y-2)/2)
+    end do
+    
+    !计算总的洪水过程线*********************************
+    do i=1,y
+        W(i)=runoff_u(i)+runoff_g(i)+Qf
+    end do
+    
+    end subroutine
+    
+

FortranWebApi.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <InvariantGlobalization>true</InvariantGlobalization>
+  </PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.0" />
+		<PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0" />
+		<PackageReference Include="Serilog" Version="4.2.0" />
+		<PackageReference Include="Serilog.AspNetCore" Version="8.0.1" />
+		<PackageReference Include="Serilog.Extensions.Logging" Version="8.0.0" />
+		<PackageReference Include="Serilog.Sinks.Console" Version="5.0.1" />
+		<PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
+		<PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />
+	</ItemGroup>
+
+  <ItemGroup>
+    <None Update="lib{{FortranFunctionName}}.so">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project> 

HttpRequests/fortranwebapi.http

@@ -0,0 +1,22 @@
+@FortranWebApi_HostAddress = http://localhost:5000
+
+### 测试Fortran请求
+
+POST {{FortranWebApi_HostAddress}}/FortranCalculate
+Content-Type: application/json
+
+{
+  "text": "{\"FuncName\":\"calculate_main\",\"ClassName\":\"\",\"Par\":[    {"Name":"S","DataType":"1","ArrayType":"0","IsOut":"2","Data":0},
+    {"Name":"QT","DataType":"1","ArrayType":"1","IsOut":"2","Data":[]},
+    {"Name":"M","DataType":"0","ArrayType":"0","IsOut":"2","Data":0},
+    {"Name":"Q","DataType":"1","ArrayType":"1","IsOut":"2","Data":[]},
+    {"Name":"N","DataType":"0","ArrayType":"0","IsOut":"2","Data":0},
+    {"Name":"IM","DataType":"1","ArrayType":"0","IsOut":"2","Data":0},
+    {"Name":"FC","DataType":"1","ArrayType":"0","IsOut":"2","Data":0},
+    {"Name":"QF","DataType":"1","ArrayType":"0","IsOut":"2","Data":0},
+    {"Name":"T","DataType":"1","ArrayType":"0","IsOut":"2","Data":0},
+    {"Name":"A","DataType":"1","ArrayType":"0","IsOut":"2","Data":0},
+    {"Name":"RUNOFF_U","DataType":"1","ArrayType":"1","IsOut":"1","Data":[]},
+    {"Name":"RUNOFF_G","DataType":"1","ArrayType":"1","IsOut":"1","Data":[]},
+    {"Name":"RUNOFF","DataType":"1","ArrayType":"1","IsOut":"1","Data":[]}]}"
+} 

Models/ApiResponse.cs

@@ -0,0 +1,31 @@
+using System.Text.Json.Serialization;
+
+namespace FortranWebApi.Models
+{
+    public class ApiResponse<T>
+    {
+        [JsonPropertyName("message")]
+        public string Message { get; set; } = "Success";
+        
+        [JsonPropertyName("success")]
+        public bool Success { get; set; } = true;
+        
+        [JsonPropertyName("data")]
+        public ApiResponseData<T>? Data { get; set; }
+    }
+
+    public class ApiResponseData<T>
+    {
+        [JsonPropertyName("contentType")]
+        public string? ContentType { get; set; }
+        
+        [JsonPropertyName("serializerSettings")]
+        public object? SerializerSettings { get; set; }
+        
+        [JsonPropertyName("statusCode")]
+        public int? StatusCode { get; set; }
+        
+        [JsonPropertyName("value")]
+        public T? Value { get; set; }
+    }
+} 

Models/FortranParameter.cs

@@ -0,0 +1,22 @@
+using System.Text.Json.Serialization;
+
+namespace FortranWebApi.Models
+{
+    public class FortranParameter
+    {
+        [JsonPropertyName("name")]
+        public string Name { get; set; } = string.Empty;
+
+        [JsonPropertyName("dataType")]
+        public string DataType { get; set; } = "0";
+
+        [JsonPropertyName("arrayType")]
+        public string ArrayType { get; set; } = "0";
+
+        [JsonPropertyName("isOut")]
+        public string IsOut { get; set; } = "2";
+
+        [JsonPropertyName("data")]
+        public object? Data { get; set; }
+    }
+} 

Models/FortranRequest.cs

@@ -0,0 +1,13 @@
+using System.Text.Json.Serialization;
+
+namespace FortranWebApi.Models
+{
+    public class FortranRequest
+    {
+        public string FuncName { get; set; } = string.Empty;
+        public string ClassName { get; set; } = string.Empty;
+        
+        [JsonPropertyName("par")]
+        public List<FortranParameter> Parameters { get; set; } = new List<FortranParameter>();
+    }
+} 

Models/FortranRequestWrapper.cs

@@ -0,0 +1,7 @@
+namespace FortranWebApi.Models
+{
+    public class FortranRequestWrapper
+    {
+        public string Text { get; set; } = string.Empty;
+    }
+} 

Program.cs

@@ -0,0 +1,80 @@
+using Serilog;
+using FortranWebApi.Services;
+using System.IO;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+// 设置库搜索路径
+string currentDir = Directory.GetCurrentDirectory();
+Environment.SetEnvironmentVariable("LD_LIBRARY_PATH", 
+    $"{Environment.GetEnvironmentVariable("LD_LIBRARY_PATH")}:{currentDir}");
+
+var builder = WebApplication.CreateBuilder(args);
+
+// 添加健康检查服务
+builder.Services.AddHealthChecks();
+
+// 配置Serilog
+Log.Logger = new LoggerConfiguration()
+    .WriteTo.Console(outputTemplate: 
+        "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}")
+    .WriteTo.File("logs/log-.txt", 
+        rollingInterval: RollingInterval.Day,
+        outputTemplate: 
+        "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}")
+    .CreateLogger();
+
+builder.Host.UseSerilog(); // 将Serilog添加到Host
+
+// 配置JSON序列化选项，使用驼峰命名法
+builder.Services.AddControllers().AddJsonOptions(options =>
+{
+    options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
+    options.JsonSerializerOptions.DictionaryKeyPolicy = JsonNamingPolicy.CamelCase;
+    options.JsonSerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
+    options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
+});
+
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+builder.Services.AddSingleton<FortranInteropService>();
+
+// 配置CORS
+builder.Services.AddCors(options =>
+{
+    options.AddDefaultPolicy(policy =>
+    {
+        policy.AllowAnyOrigin()
+              .AllowAnyMethod()
+              .AllowAnyHeader();
+    });
+});
+
+var app = builder.Build();
+
+// Configure the HTTP request pipeline.
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseCors();
+app.UseAuthorization();
+// 映射健康检查端点
+app.MapHealthChecks("/health");
+app.MapControllers();
+
+try
+{
+    Log.Information("启动应用程序...");
+    app.Run();
+}
+catch (Exception ex)
+{
+    Log.Fatal(ex, "应用程序启动失败");
+}
+finally
+{
+    Log.CloseAndFlush();
+}

Properties/launchSettings.json

@@ -0,0 +1,14 @@
+{
+  "profiles": {
+    "FortranWebApi": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "dotnetRunMessages": true,
+      "applicationUrl": "http://0.0.0.0:5000"
+    }
+  }
+}

Services/FortranInteropService.cs

@@ -0,0 +1,562 @@
+using System.Runtime.InteropServices;
+using FortranWebApi.Models;
+using System.Text.Json;
+using System.Runtime.InteropServices.Marshalling;
+using System.IO;
+
+namespace FortranWebApi.Services
+{
+    public class FortranInteropService
+    {
+        // 静态构造函数设置DLL导入解析器
+        static FortranInteropService()
+        {
+            // 添加当前目录到库搜索路径
+            NativeLibrary.SetDllImportResolver(typeof(FortranInteropService).Assembly, (name, assembly, path) =>
+            {
+                if (name == "libSUB_UNITHYDRO.so")
+                {
+                    // 尝试从当前目录加载
+                    string currentDir = Directory.GetCurrentDirectory();
+                    string libraryPath = Path.Combine(currentDir, "libSUB_UNITHYDRO.so");
+                    
+                    if (File.Exists(libraryPath))
+                    {
+                        return NativeLibrary.Load(libraryPath);
+                    }
+                }
+                
+                // 回退到默认加载行为
+                return IntPtr.Zero;
+            });
+        }
+
+        // DllImport声明
+        [DllImport("libSUB_UNITHYDRO.so", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SUB_UNITHYDRO")]
+        private static extern void SUB_UNITHYDRO(
+            ref float S,
+            float[] QT,
+            ref int M,
+            float[] Q,
+            ref int N,
+            ref float IM,
+            ref float FC,
+            ref float QF,
+            ref float T,
+            ref float A,
+            float[] RUNOFF_U,
+            float[] RUNOFF_G,
+            float[] RUNOFF
+        );
+
+        public string ProcessFortranRequest(string requestText)
+        {
+            try
+            {
+                // 解析请求
+                var options = new JsonSerializerOptions
+                {
+                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+                    DictionaryKeyPolicy = JsonNamingPolicy.CamelCase,
+                    PropertyNameCaseInsensitive = true,
+                    WriteIndented = true
+                };
+                
+                var request = JsonSerializer.Deserialize<FortranRequest>(requestText, options);
+                if (request == null)
+                {
+                    throw new ArgumentException("无效的请求格式");
+                }
+
+                // 准备输入参数
+                var parameters = request.Parameters;
+                
+                // 提取参数
+                float S = GetFloatParameter(parameters, "S");
+                float[] QT = GetFloatArrayParameter(parameters, "QT");
+                int M = GetIntParameter(parameters, "M");
+                float[] Q = GetFloatArrayParameter(parameters, "Q");
+                int N = GetIntParameter(parameters, "N");
+                float IM = GetFloatParameter(parameters, "IM");
+                float FC = GetFloatParameter(parameters, "FC");
+                float QF = GetFloatParameter(parameters, "QF");
+                float T = GetFloatParameter(parameters, "T");
+                float A = GetFloatParameter(parameters, "A");
+
+
+                // 准备数组参数
+                float[] RUNOFF_U = new float[10000]; // 输出数组，初始大小为10000
+                float[] RUNOFF_G = new float[10000]; // 输出数组，初始大小为10000
+                float[] RUNOFF = new float[10000]; // 输出数组，初始大小为10000
+
+
+                // 调用Fortran函数
+                SUB_UNITHYDRO(
+                    ref S,
+                    QT,
+                    ref M,
+                    Q,
+                    ref N,
+                    ref IM,
+                    ref FC,
+                    ref QF,
+                    ref T,
+                    ref A,
+                    RUNOFF_U,
+                    RUNOFF_G,
+                    RUNOFF
+                );
+
+                // 更新输出参数
+                UpdateArrayParameter(parameters, "RUNOFF_U", RUNOFF_U);
+                UpdateArrayParameter(parameters, "RUNOFF_G", RUNOFF_G);
+                UpdateArrayParameter(parameters, "RUNOFF", RUNOFF);
+
+
+                // 处理输出数组
+                // 处理输出数组 RUNOFF_U
+                // 注意：没有找到明确的长度参数，使用非零元素数量
+                {
+                    int nonZeroCount = 0;
+                    for (int i = 0; i < RUNOFF_U.Length; i++)
+                    {
+                        if (RUNOFF_U[i] != 0) nonZeroCount = i + 1;
+                    }
+                    if (nonZeroCount > 0)
+                    {
+                        float[] resultArray = new float[nonZeroCount];
+                        Array.Copy(RUNOFF_U, resultArray, nonZeroCount);
+                        UpdateArrayParameter(parameters, "RUNOFF_U", resultArray);
+                    }
+                }
+                // 处理输出数组 RUNOFF_G
+                // 注意：没有找到明确的长度参数，使用非零元素数量
+                {
+                    int nonZeroCount = 0;
+                    for (int i = 0; i < RUNOFF_G.Length; i++)
+                    {
+                        if (RUNOFF_G[i] != 0) nonZeroCount = i + 1;
+                    }
+                    if (nonZeroCount > 0)
+                    {
+                        float[] resultArray = new float[nonZeroCount];
+                        Array.Copy(RUNOFF_G, resultArray, nonZeroCount);
+                        UpdateArrayParameter(parameters, "RUNOFF_G", resultArray);
+                    }
+                }
+                // 处理输出数组 RUNOFF
+                // 注意：没有找到明确的长度参数，使用非零元素数量
+                {
+                    int nonZeroCount = 0;
+                    for (int i = 0; i < RUNOFF.Length; i++)
+                    {
+                        if (RUNOFF[i] != 0) nonZeroCount = i + 1;
+                    }
+                    if (nonZeroCount > 0)
+                    {
+                        float[] resultArray = new float[nonZeroCount];
+                        Array.Copy(RUNOFF, resultArray, nonZeroCount);
+                        UpdateArrayParameter(parameters, "RUNOFF", resultArray);
+                    }
+                }
+
+
+                // 返回结果 - 只返回原始请求的结构，但包含更新后的参数
+                var result = new FortranRequest
+                {
+                    FuncName = request.FuncName,
+                    ClassName = request.ClassName,
+                    Parameters = parameters
+                };
+                
+                return JsonSerializer.Serialize(result, options);
+            }
+            catch (Exception ex)
+            {
+                return JsonSerializer.Serialize(new { error = ex.Message });
+            }
+        }
+
+        private float GetFloatParameter(List<FortranParameter> parameters, string name)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param == null || param.Data == null)
+            {
+                return 0.0f;
+            }
+            
+            if (param.Data is JsonElement element)
+            {
+                if (element.ValueKind == JsonValueKind.Number)
+                {
+                    return element.GetSingle();
+                }
+            }
+            
+            return Convert.ToSingle(param.Data);
+        }
+        private double GetDoubleParameter(List<FortranParameter> parameters, string name)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param == null || param.Data == null)
+            {
+                return 0.0;
+            }
+
+            if (param.Data is JsonElement element)
+            {
+                if (element.ValueKind == JsonValueKind.Number)
+                {
+                    return element.GetSingle();
+                }
+            }
+
+            return Convert.ToDouble(param.Data);
+        }
+        private int GetIntParameter(List<FortranParameter> parameters, string name)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param == null || param.Data == null)
+            {
+                return 0;
+            }
+            
+            if (param.Data is JsonElement element)
+            {
+                if (element.ValueKind == JsonValueKind.Number)
+                {
+                    return element.GetInt32();
+                }
+            }
+            
+            return Convert.ToInt32(param.Data);
+        }
+        private int[] GetIntArrayParameter(List<FortranParameter> parameters, string name)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param == null || param.Data == null)
+            {
+                return Array.Empty<int>();
+            }
+
+            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
+            {
+                var array = new List<int>();
+                foreach (var item in element.EnumerateArray())
+                {
+                    if (item.ValueKind == JsonValueKind.Number)
+                    {
+                        array.Add(item.GetInt32());
+                    }
+                }
+                return array.ToArray();
+            }
+
+            if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
+            {
+                var array = new List<int>();
+                foreach (var item in enumerable)
+                {
+                    array.Add(Convert.ToInt32(item));
+                }
+                return array.ToArray();
+            }
+
+            return Array.Empty<int>();
+        }
+        private float[] GetFloatArrayParameter(List<FortranParameter> parameters, string name)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param == null || param.Data == null)
+            {
+                return Array.Empty<float>();
+            }
+            
+            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
+            {
+                var array = new List<float>();
+                foreach (var item in element.EnumerateArray())
+                {
+                    if (item.ValueKind == JsonValueKind.Number)
+                    {
+                        array.Add(item.GetSingle());
+                    }
+                }
+                return array.ToArray();
+            }
+            
+            if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
+            {
+                var array = new List<float>();
+                foreach (var item in enumerable)
+                {
+                    array.Add(Convert.ToSingle(item));
+                }
+                return array.ToArray();
+            }
+            
+            return Array.Empty<float>();
+        }
+        private double[] GetDoubleArrayParameter(List<FortranParameter> parameters, string name)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param == null || param.Data == null)
+            {
+                return Array.Empty<double>();
+            }
+
+            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
+            {
+                var array = new List<double>();
+                foreach (var item in element.EnumerateArray())
+                {
+                    if (item.ValueKind == JsonValueKind.Number)
+                    {
+                        array.Add(item.GetSingle());
+                    }
+                }
+                return array.ToArray();
+            }
+
+            if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
+            {
+                var array = new List<double>();
+                foreach (var item in enumerable)
+                {
+                    array.Add(Convert.ToSingle(item));
+                }
+                return array.ToArray();
+            }
+
+            return Array.Empty<double>();
+        }
+        private void UpdateParameter(List<FortranParameter> parameters, string name, object value)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param != null)
+            {
+                param.Data = value;
+            }
+        }
+
+        private void UpdateArrayParameter(List<FortranParameter> parameters, string name, float[] value)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param != null)
+            {
+                param.Data = value;
+            }
+        }
+        private void UpdateDoubleArrayParameter(List<FortranParameter> parameters, string name, double[] value)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param != null)
+            {
+                param.Data = value;
+            }
+        }
+        private void UpdateIntArrayParameter(List<FortranParameter> parameters, string name, int[] value)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param != null)
+            {
+                param.Data = value;
+            }
+        }
+        // 添加新的辅助方法来处理二维数组
+        private double[,] GetDouble2DArrayParameter(List<FortranParameter> parameters, string name, int rows, int cols)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param == null || param.Data == null)
+            {
+                return new double[rows, cols];
+            }
+
+            double[,] result = new double[rows, cols];
+
+            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
+            {
+                int index = 0;
+                foreach (var item in element.EnumerateArray())
+                {
+                    if (item.ValueKind == JsonValueKind.Number)
+                    {
+                        int row = index / cols;
+                        int col = index % cols;
+                        if (row < rows && col < cols)
+                        {
+                            result[row, col] = item.GetDouble();
+                        }
+                        index++;
+                    }
+                }
+            }
+            else if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
+            {
+                int index = 0;
+                foreach (var item in enumerable)
+                {
+                    int row = index / cols;
+                    int col = index % cols;
+                    if (row < rows && col < cols)
+                    {
+                        result[row, col] = Convert.ToDouble(item);
+                    }
+                    index++;
+                }
+            }
+
+            return result;
+        }
+
+        // 添加更新二维数组参数的方法
+        private void UpdateDouble2DArrayParameter(List<FortranParameter> parameters, string name, double[,] value)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param != null)
+            {
+                // 将二维数组转换为一维数组以便于JSON序列化
+                int rows = value.GetLength(0);
+                int cols = value.GetLength(1);
+                double[] flatArray = new double[rows * cols];
+                for (int i = 0; i < rows; i++)
+                {
+                    for (int j = 0; j < cols; j++)
+                    {
+                        flatArray[i * cols + j] = value[i, j];
+                    }
+                }
+                param.Data = flatArray;
+            }
+        }
+        // float版本
+        private float[,] GetFloat2DArrayParameter(List<FortranParameter> parameters, string name, int rows, int cols)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param == null || param.Data == null)
+            {
+                return new float[rows, cols];
+            }
+
+            float[,] result = new float[rows, cols];
+
+            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
+            {
+                int index = 0;
+                foreach (var item in element.EnumerateArray())
+                {
+                    if (item.ValueKind == JsonValueKind.Number)
+                    {
+                        int row = index / cols;
+                        int col = index % cols;
+                        if (row < rows && col < cols)
+                        {
+                            result[row, col] = item.GetSingle();
+                        }
+                        index++;
+                    }
+                }
+            }
+            else if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
+            {
+                int index = 0;
+                foreach (var item in enumerable)
+                {
+                    int row = index / cols;
+                    int col = index % cols;
+                    if (row < rows && col < cols)
+                    {
+                        result[row, col] = Convert.ToSingle(item);
+                    }
+                    index++;
+                }
+            }
+
+            return result;
+        }
+
+        private void UpdateFloat2DArrayParameter(List<FortranParameter> parameters, string name, float[,] value)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param != null)
+            {
+                int rows = value.GetLength(0);
+                int cols = value.GetLength(1);
+                float[] flatArray = new float[rows * cols];
+                for (int i = 0; i < rows; i++)
+                {
+                    for (int j = 0; j < cols; j++)
+                    {
+                        flatArray[i * cols + j] = value[i, j];
+                    }
+                }
+                param.Data = flatArray;
+            }
+        }
+
+        // int版本
+        private int[,] GetInt2DArrayParameter(List<FortranParameter> parameters, string name, int rows, int cols)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param == null || param.Data == null)
+            {
+                return new int[rows, cols];
+            }
+
+            int[,] result = new int[rows, cols];
+
+            if (param.Data is JsonElement element && element.ValueKind == JsonValueKind.Array)
+            {
+                int index = 0;
+                foreach (var item in element.EnumerateArray())
+                {
+                    if (item.ValueKind == JsonValueKind.Number)
+                    {
+                        int row = index / cols;
+                        int col = index % cols;
+                        if (row < rows && col < cols)
+                        {
+                            result[row, col] = item.GetInt32();
+                        }
+                        index++;
+                    }
+                }
+            }
+            else if (param.Data is System.Collections.IEnumerable enumerable && !(param.Data is string))
+            {
+                int index = 0;
+                foreach (var item in enumerable)
+                {
+                    int row = index / cols;
+                    int col = index % cols;
+                    if (row < rows && col < cols)
+                    {
+                        result[row, col] = Convert.ToInt32(item);
+                    }
+                    index++;
+                }
+            }
+
+            return result;
+        }
+
+        private void UpdateInt2DArrayParameter(List<FortranParameter> parameters, string name, int[,] value)
+        {
+            var param = parameters.FirstOrDefault(p => p.Name == name);
+            if (param != null)
+            {
+                int rows = value.GetLength(0);
+                int cols = value.GetLength(1);
+                int[] flatArray = new int[rows * cols];
+                for (int i = 0; i < rows; i++)
+                {
+                    for (int j = 0; j < cols; j++)
+                    {
+                        flatArray[i * cols + j] = value[i, j];
+                    }
+                }
+                param.Data = flatArray;
+            }
+        }
+    }
+} 

appsettings.json

@@ -0,0 +1,16 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*",
+  "Kestrel": {
+    "Endpoints": {
+      "Http": {
+        "Url": "http://0.0.0.0:5000"
+      }
+    }
+  }
+}