C# 将结果记录在控制台asp.net Core上

我想对我的应用程序进行测试，为此我从Prometheus API获取信息，我将其放在一个模型上，并尝试从我的控制器中提取数据。 我如何在我的控制台上获取数据（类似于

console.Write

），你有什么想法吗？我也尝试过调试，但我不知道如何使用VisualStudioDeBogger。 请温柔一点，我是新手，谢谢

获取Json数据的数据模型：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

using System.Globalization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

namespace Prometheus_test_api.Models
{
    public partial class FreeDiskSpace
    {
        [JsonProperty("status")]
        public string Status { get; set; }

        [JsonProperty("data")]
        public Data Data { get; set; }
    }

    public partial class Data
    {
        [JsonProperty("resultType")]
        public string ResultType { get; set; }

        [JsonProperty("result")]
        public Result[] Result { get; set; }
    }

    public partial class Result
    {
        [JsonProperty("metric")]
        public Metric Metric { get; set; }

        [JsonProperty("value")]
        public Value[] Value { get; set; }
    }

    public partial class Metric
    {
        [JsonProperty("__name__")]
        public string Name { get; set; }

        [JsonProperty("instance")]
        public string Instance { get; set; }

        [JsonProperty("job")]
        public string Job { get; set; }

        [JsonProperty("volume")]
        public string Volume { get; set; }
    }

    public partial struct Value
    {
        public double? Double;
        public string String;

        public static implicit operator Value(double Double) => new Value { Double = Double };
        public static implicit operator Value(string String) => new Value { String = String };
    }

    internal static class Converter
    {
        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
        {
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
            Converters =
            {
                ValueConverter.Singleton,
                new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
            },
        };
    }

    internal class ValueConverter : JsonConverter
    {
        public override bool CanConvert(Type t) => t == typeof(Value) || t == typeof(Value?);

        public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
        {
            switch (reader.TokenType)
            {
                case JsonToken.Integer:
                case JsonToken.Float:
                    var doubleValue = serializer.Deserialize<double>(reader);
                    return new Value { Double = doubleValue };
                case JsonToken.String:
                case JsonToken.Date:
                    var stringValue = serializer.Deserialize<string>(reader);
                    return new Value { String = stringValue };
            }
            throw new Exception("Cannot unmarshal type Value");
        }

        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
        {
            var value = (Value)untypedValue;
            if (value.Double != null)
            {
                serializer.Serialize(writer, value.Double.Value);
                return;
            }
            if (value.String != null)
            {
                serializer.Serialize(writer, value.String);
                return;
            }
            throw new Exception("Cannot marshal type Value");
        }

        public static readonly ValueConverter Singleton = new ValueConverter();
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用System.Threading.Tasks；
利用制度全球化；
使用Newtonsoft.Json；
使用Newtonsoft.Json.Converters；
名称空间Prometheus_test_api.Models
{
公共部分类空闲磁盘空间
{
[JsonProperty（“状态”）]
公共字符串状态{get；set；}
[JsonProperty（“数据”）]
公共数据数据{get；set；}
}
公共部分类数据
{
[JsonProperty（“resultType”）]
公共字符串结果类型{get；set；}
[JsonProperty（“结果”）]
公共结果[]结果{get；set；}
}
公共部分类结果
{
[JsonProperty（“公制”）]
公共度量{get；set；}
[JsonProperty（“价值”）]
公共值[]值{get；set；}
}
公共部分类度量
{
[JsonProperty（“\uuuuuuuuuu名称”）]
公共字符串名称{get；set；}
[JsonProperty（“实例”）]
公共字符串实例{get；set；}
[JsonProperty（“作业”）]
公共字符串作业{get；set；}
[JsonProperty（“卷”）]
公共字符串卷{get；set；}
}
公共部分结构值
{
公共双？双；
公共字符串；
公共静态隐式运算符值（double-double）=>新值{double=double}；
公共静态隐式运算符值（字符串）=>新值{string=string}；
}
内部静态类转换器
{
公共静态只读JsonSerializerSettings设置=新JsonSerializerSettings
{
MetadataPropertyHandling=MetadataPropertyHandling.Ignore，
DateParseHandling=DateParseHandling.None，
转换器=
{
ValueConverter.Singleton，
新的IsoDateTimeConverter{DateTimeStyles=DateTimeStyles.AssumeUniversal}
},
};
}
内部类值转换器：JsonConverter
{
公共覆盖布尔CanConvert（Type t）=>t==typeof（Value）| | t==typeof（Value？）；
公共重写对象ReadJson（JsonReader阅读器，类型t，对象existingValue，JsonSerializer序列化程序）
{
开关（reader.TokenType）
{
案例JsonToken.Integer：
case JsonToken.Float：
var doubleValue=序列化程序。反序列化（读取器）；
返回新值{Double=doubleValue}；
case JsonToken.String：
案例JsonToken。日期：
var stringValue=serializer.Deserialize（读取器）；
返回新值{String=stringValue}；
}
抛出新异常（“无法解组类型值”）；
}
public override void WriteJson（JsonWriter编写器、对象非类型化值、JsonSerializer序列化器）
{
var值=（值）非类型值；
如果（value.Double！=null）
{
serializer.Serialize（writer，value.Double.value）；
返回；
}
if（value.String！=null）
{
serializer.Serialize（writer，value.String）；
返回；
}
抛出新异常（“无法封送类型值”）；
}
public static readonly ValueConverter Singleton=new ValueConverter（）；
}
}

和我的控制器：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Prometheus_test_api.Models;
using Microsoft.Extensions.Logging.Debug;

namespace Prometheus_test_api.Controllers
{
    public class FreeDiskSpaceController : Controller
    {
        private readonly ILogger<FreeDiskSpaceController> _logger;

        public FreeDiskSpaceController(ILogger<FreeDiskSpaceController> logger)
        {
            _logger = logger;
        }

        public ActionResult Index()
        {
            IEnumerable<FreeDiskSpace> JsonData = null;

            using (var client = new HttpClient())
            {
                client.BaseAddress 
                    = new Uri("http://localhost:9090/api/v1/query?");
                //HTTP GET
                var responseTask = client.GetAsync("query=wmi_logical_disk_free_bytes");
                responseTask.Wait();

                var result = responseTask.Result;
                if (result.IsSuccessStatusCode)
                {
                    var readTask = result.Content.ReadAsAsync<IList<FreeDiskSpace>>();
                    readTask.Wait();

                    JsonData = readTask.Result;
                }
                else //web api sent error response 
                {
                    //log response status here..

                    JsonData = Enumerable.Empty<FreeDiskSpace>();

                    ModelState.AddModelError(string.Empty, "Server error. Please contact administrator.");
                }
            }
            Console.WriteLine(JsonData);
            return View(JsonData);
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用System.Net.Http；
使用System.Threading.Tasks；
使用Microsoft.AspNetCore.Mvc；
使用Microsoft.Extensions.Logging；
使用普罗米修斯测试api模型；
使用Microsoft.Extensions.Logging.Debug；
名称空间Prometheus_test_api.Controllers
{
公共类FreeDiskSpaceController:控制器
{
专用只读ILogger\u记录器；
公共FreeDiskSpaceController（ILogger记录器）
{
_记录器=记录器；
}
公共行动结果索引（）
{
IEnumerable JsonData=null；
使用（var client=new HttpClient（））
{
client.BaseAddress
=新Uri（“http://localhost:9090/api/v1/query?");
//HTTP获取
var responseTask=client.GetAsync（“query=wmi\u logical\u disk\u free\u bytes”）；
responseTask.Wait（）；
var结果=响应任务结果；
if（结果。IsSuccessStatusCode）
{
var readTask=result.Content.ReadAsAsync（）；
readTask.Wait（）；
JsonData=readTask.Result；
}
else//web api发送了错误响应
{
//在此处记录响应状态。。
JsonData=Enumerable.Empty（）；
AddModelError（string.Empty，“服务器错误。请与管理员联系”）；
}
}
Console.WriteLine（JsonData）；
返回视图（JsonData）；
}
}
}

---

如果可能的话，请帮助我将信息记录在Razor页面或控制台中，谢谢。

您可以通过按F9将debbug停止在任何行上，并将鼠标拖动到要检查的变量上，VS将显示该变量中存储的内容

OBS：确保在调试模式下运行您的项目，如果它处于发行版，VS将忽略您的停止