C# var a = new char[];该如何修改

在C#中，当你想要创建一个字符数组但不立即初始化它时，可以使用`var`关键字和空数组花括号来声明一个可变大小的字符数组。不需要使用`new`关键字。下面是如何修改`var a`的声明：

var a = new char[] {}; // 创建一个空的字符数组

如果你想后续添加元素，可以直接通过索引赋值：

a = new char[] {'h', 'e', 'l', 'l', 'o'}; // 初始化为指定字符

如果需要动态添加元素，可以使用`Array.Resize`方法或直接添加到数组的末尾：

char[] a;
// 增加数组长度并添加元素
a = new char[5]; // 初始长度为5
a[0] = 'h'; // 添加第一个元素
Array.Resize(ref a, 6); // 扩展数组到长度6
a[5] = '!';

然而，需要注意的是，如果你试图比较两个未初始化的字符数组（如`var a = new char[] {}` 和 `var b = new char[] {}`），它们实际上是相等的，因为它们都是空的，直到填充了具体内容才会改变：

var a = new char[] {};
var b = new char[] {};

Console.WriteLine("ostr1==ostr2 " + (a == b)); // 结果为true

相关问题

怎么把这段c#转换为c++dll函数实现，并在最后把c返回给c# InferenceSession session = new InferenceSession(modelPath); Mat src_f = copy_from_mat(img); var wl = m_width * m_height; VectorOfMat temp = new VectorOfMat(); CvInvoke.Split(src_f, temp); float[] typedArr = new float[3 * m_width * m_height]; unsafe { fixed (float* target = typedArr) { for (int i = 0; i < temp.Size; i++) { var rawDataPointer = temp[i].DataPointer; Buffer.MemoryCopy((byte*)rawDataPointer, (byte*)target + (i * wl * sizeof(float)), wl * sizeof(float), wl * sizeof(float)); } } } var input = new DenseTensor<float>(typedArr, new[] { 1, 3, m_height, m_width }); var inputs = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor("images", input) }; var results = session.Run(inputs).ToArray(); //var ooo = results[0].AsTensor<float>(); float[] c = results[0].AsTensor<float>().ToArray();

以下是将该段代码转换为C++ DLL函数的实现，并在最后将C++返回给C#的示例代码：

首先，需要在C++中引入相关头文件和命名空间：

#include <vector>
#include <string>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <numeric>
#include <chrono>
#include <memory>
#include <stdexcept>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cmath>

#include <onnxruntime_cxx_api.h>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;
using namespace onnxruntime;

然后，实现C++ DLL函数：

// 将Mat对象复制到float数组
void copy_from_mat(Mat& img, float* target) {
    vector<Mat> temp;
    split(img, temp);
    int wl = img.cols * img.rows;
    for (int i = 0; i < temp.size(); i++) {
        uchar* rawDataPointer = temp[i].data;
        memcpy(target + i * wl, rawDataPointer, wl * sizeof(float));
    }
}

// 将C++返回给C#的结果转换为float数组
void results_to_float_array(OrtValue& result, float* c) {
    auto tensor = result.GetTensor<float>();
    auto tensor_shape = tensor.Shape();
    int num_elements = tensor_shape.Size();
    memcpy(c, tensor.Data(), num_elements * sizeof(float));
}

// 实现C++ DLL函数
extern "C" __declspec(dllexport) int run_session(float* img_data, int img_width, int img_height, char* model_path, float* c) {
    try {
        // 初始化InferenceSession
        SessionOptions session_options;
        session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL);
        session_options.SetExecutionMode(ExecutionMode::ORT_SEQUENTIAL);
        session_options.SetIntraOpNumThreads(1);
        session_options.SetInterOpNumThreads(1);
        session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED);
        InferenceSession session(session_options);
        OrtMemoryInfo info("Cpu", OrtDeviceAllocator, 0, OrtMemTypeCPU);

        // 加载模型
        session.LoadModel(model_path);

        // 将输入数据复制到DenseTensor
        float* typedArr = new float[3 * img_width * img_height];
        copy_from_mat(img, typedArr);
        vector<int64_t> dims = {1, 3, img_height, img_width};
        auto input = OrtValue::CreateTensor<float>(info, typedArr, num_elements, dims.data(), dims.size());
        delete[] typedArr;

        // 执行推理
        vector<OrtValue> ort_outputs = session.Run({ {session.GetInputName(0), input} });

        // 将输出结果转换为float数组
        results_to_float_array(ort_outputs[0], c);

        return 0;
    } catch (const exception& ex) {
        cerr << ex.what() << endl;
        return -1;
    }
}

最后，需要在C#中声明C++ DLL函数，并调用该函数：

[DllImport("your_dll_name.dll")]
public static extern int run_session(float[] img_data, int img_width, int img_height, string model_path, float[] c);

// 调用C++ DLL函数
float[] img_data = ...; // 输入图像数据
int img_width = ...; // 输入图像宽度
int img_height = ...; // 输入图像高度
string model_path = ...; // 模型路径
float[] c = new float[...]; // 存储输出结果的数组
int ret = run_session(img_data, img_width, img_height, model_path, c);
if (ret == 0) {
    // 输出结果处理代码
} else {
    // 处理错误
}

怎么把这段c#转换为在c++中的dll函数实现，并在最后把float[] c返回给到c#，注意c++中的session和和c#的inferencesession不同 InferenceSession session = new InferenceSession(modelPath); Mat src_f = copy_from_mat(img); var wl = m_width * m_height; VectorOfMat temp = new VectorOfMat(); CvInvoke.Split(src_f, temp); float[] typedArr = new float[3 * m_width * m_height]; unsafe { fixed (float* target = typedArr) { for (int i = 0; i < temp.Size; i++) { var rawDataPointer = temp[i].DataPointer; Buffer.MemoryCopy((byte*)rawDataPointer, (byte*)target + (i * wl * sizeof(float)), wl * sizeof(float), wl * sizeof(float)); } } } var input = new DenseTensor<float>(typedArr, new[] { 1, 3, m_height, m_width }); var inputs = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor("images", input) }; var results = session.Run(inputs).ToArray(); //var ooo = results[0].AsTensor<float>(); float[] c = results[0].AsTensor<float>().ToArray();

你想要将上述C#代码转换为C++的DLL函数，以便在C#中使用。下面是一个可能的实现：

首先，你需要包含以下头文件：

#include <vector>
#include <memory>
#include <string>
#include "onnxruntime_cxx_api.h"
#include "opencv2/opencv.hpp"

接下来，你可以编写一个函数，该函数将接收模型路径和OpenCV图像作为输入，并返回结果数组。请注意，为了将结果传递回C#，你需要使用指针并将其包装在一个结构体中。

typedef struct {
    float* data;
    int size;
} FloatArray;

FloatArray run_inference(const char* model_path, cv::Mat img) {
    // Load the model
    Ort::SessionOptions session_options;
    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "onnx");
    Ort::Session session(env, model_path, session_options);

    // Convert the image to a float array
    int m_width = img.cols;
    int m_height = img.rows;
    cv::Mat src_f;
    img.convertTo(src_f, CV_32FC3);
    std::vector<cv::Mat> temp;
    cv::split(src_f, temp);
    float* typedArr = new float[3 * m_width * m_height];
    for (int i = 0; i < temp.size(); i++) {
        std::memcpy(typedArr + (i * m_width * m_height), temp[i].data, m_width * m_height * sizeof(float));
    }

    // Create the input tensor
    Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
    std::vector<int64_t> input_shape = { 1, 3, m_height, m_width };
    Ort::Value input_tensor = Ort::Value::CreateTensor<float>(memory_info, typedArr, 3 * m_width * m_height, input_shape.data(), input_shape.size());

    // Run the inference
    const char* input_names[] = { "images" };
    Ort::RunOptions run_options;
    std::vector<Ort::Value> inputs = { input_tensor };
    std::vector<const char*> output_names = { "output" };
    std::vector<Ort::Value> output_tensors = session.Run(run_options, input_names, inputs.data(), inputs.size(), output_names.data(), output_names.size());

    // Convert the output tensor to a float array
    float* output_data = output_tensors[0].GetTensorMutableData<float>();
    int output_size = output_tensors[0].GetTensorTypeAndShapeInfo().GetElementCount();
    FloatArray result = { output_data, output_size };

    // Clean up
    delete[] typedArr;

    return result;
}

最后，你需要将该函数导出到DLL。这可以通过以下方式完成：

extern "C" __declspec(dllexport) FloatArray __cdecl run_inference(const char* model_path, cv::Mat img);

现在你可以在C#中调用此函数，并将结果转换为float数组。