c# - 写一个二进制文件到struct c#-6ren

c# - 写一个二进制文件到struct c#

转载作者：塔克拉玛干更新时间：2023-11-03 07:12:08

所以，我阅读了大量相同的主题，但我无法找到解决方案。我已经使用 C++ 制作了一个导入程序(二进制到结构)代码，现在我想制作 Shiny 的表格并正确传输我的代码。在这种情况下，C# 与 C++ 有很大不同，所以我不得不重做很多东西，而且还会有更多。这是我的 C++ 代码:

#include "stdafx.h"
#include "half.h"
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;
using half_float::half;

#pragma pack(push, 1)
struct Group {
    uint8_t Name[32];
};
struct WeaponBonesData {
    uint8_t WeaponBoneName[32];
    uint8_t Unknown5[48];
    uint32_t WeaponBoneID;
};
struct TexturesData {
    uint32_t TextureType;
    uint8_t TextureName[256];
};
struct Shader {
    float DetailTileU;
    uint32_t Unknown7;
    float DetailTileV;
    uint32_t Unknown8;
    uint32_t DirtTileU;
    uint32_t Unknown9;
    uint32_t DirtTileV;
    uint32_t Unknown10;
};
struct VertexData {
    half X;
    half Y;
    half Z;
    half Sep1;
    bool bone0;
    bool bone1;
    bool weight;
    bool Sep2;
    bool normX;
    bool normY;
    bool normZ;
    bool Sep3;
    half U;
    half V;
    uint32_t Unknown11[2];
};
struct IndexData {
    uint16_t ind1;
    uint16_t ind2;
    uint16_t ind3;
};
struct Geometry {
    vector<VertexData> Vertices;
    vector<IndexData> Indices;
};
struct rigid_model {
    uint32_t rigid_material_ID;
    vector<uint32_t> LodSize;
    vector<uint32_t> LodVerticesOffset;
    vector<uint32_t> VerticesCount;
    vector<uint32_t> LodIndicesOffset;
    vector<uint32_t> IndicesCount;
    vector<float> GroupMinX;
    vector<float> GroupMinY;
    vector<float> GroupMinZ;
    vector<float> GroupMaxX;
    vector<float> GroupMaxY;
    vector<float> GroupMaxZ;
    uint8_t ShaderMaterial[12];
    uint8_t Unknown1[20];
    uint16_t Unknown2;
    vector<Group> GroupName;
    uint8_t TexturesDir[256];
    uint8_t Unknown3[422];
    uint32_t WeaponBonesCount;
    uint32_t TexturesCount;
    uint8_t Unknown4[140];
    WeaponBonesData WeaponBones[5];
    vector<TexturesData> TexData;
    uint32_t NullMask;
    Shader ShaderParams;
    uint32_t AlphaMode;
    vector<Geometry>  Mesh;
};
struct RMV2 {
    uint8_t Signature[4];
    uint32_t ModelType;
    uint32_t LodsCount;
    uint8_t SkeletonName[128];
    vector<uint32_t> GroupsCount;
    vector<uint32_t> VDCount;
    vector<uint32_t> IDCount;
    vector<uint32_t> StartOffset;
    vector<float> ZoomFactor;
    vector<rigid_model> lod;
};
#pragma pack(pop)

ostream& operator<<(ostream& os, const WeaponBonesData& WBD) {
    return os << WBD.WeaponBoneName << WBD.Unknown5 << WBD.WeaponBoneID;
}
ostream& operator<<(ostream& os, const Group& g) {
    return os << g.Name;
}

void read(RMV2 &rmv2, char filename[128]) {
    ifstream model(filename, ios::in | ios::binary);
    if (model.fail()) {
        cout << "ERROR! Invalid file name" << endl;
        system("pause");
        exit(0);
    }
    model.read((char*)&rmv2, 140);

    rigid_model data;
    uint32_t temp;
    float temp2;
    TexturesData TD;
    VertexData vertex;
    IndexData index;
    Geometry geometry;
    Group group;
    for (size_t i = 0; i < rmv2.LodsCount; i++) {
        model.read((char*)&temp, sizeof(uint32_t));
        rmv2.GroupsCount.push_back(temp);
        model.read((char*)&temp, sizeof(uint32_t));
        rmv2.VDCount.push_back(temp);
        model.read((char*)&temp, sizeof(uint32_t));
        rmv2.IDCount.push_back(temp);
        model.read((char*)&temp, sizeof(uint32_t));
        rmv2.StartOffset.push_back(temp);
        model.read((char*)&temp2, sizeof(float));
        rmv2.ZoomFactor.push_back(temp2);
    }
    for (size_t i = 0; i < rmv2.LodsCount; i++) {
        for (size_t j = 0; j < rmv2.GroupsCount[i]; j++) {
            model.read((char*)&data.rigid_material_ID, sizeof(data.rigid_material_ID));
            model.read((char*)&temp, sizeof(uint32_t));
            data.LodSize.push_back(temp);
            model.read((char*)&temp, sizeof(uint32_t));
            data.LodVerticesOffset.push_back(temp);
            model.read((char*)&temp, sizeof(uint32_t));
            data.VerticesCount.push_back(temp);
            model.read((char*)&temp, sizeof(uint32_t));
            data.LodIndicesOffset.push_back(temp);
            model.read((char*)&temp, sizeof(uint32_t));
            data.IndicesCount.push_back(temp);
            model.read((char*)&temp2, sizeof(float));
            data.GroupMinX.push_back(temp2);
            model.read((char*)&temp2, sizeof(float));
            data.GroupMinY.push_back(temp2);
            model.read((char*)&temp2, sizeof(float));
            data.GroupMinZ.push_back(temp2);
            model.read((char*)&temp2, sizeof(float));
            data.GroupMaxX.push_back(temp2);
            model.read((char*)&temp2, sizeof(float));
            data.GroupMaxY.push_back(temp2);
            model.read((char*)&temp2, sizeof(float));
            data.GroupMaxZ.push_back(temp2);
            model.read((char*)&data.ShaderMaterial, sizeof(data.ShaderMaterial));
            model.read((char*)&data.Unknown1, sizeof(data.Unknown1));
            model.read((char*)&data.Unknown2, sizeof(data.Unknown2));
            model.read((char*)&group, sizeof(group));
            data.GroupName.push_back(group);
            model.read((char*)&data.TexturesDir, sizeof(data.TexturesDir));
            model.read((char*)&data.Unknown3, sizeof(data.Unknown3));
            model.read((char*)&data.WeaponBonesCount, sizeof(data.WeaponBonesCount));
            model.read((char*)&data.TexturesCount, sizeof(data.TexturesCount));
            model.read((char*)&data.Unknown4, sizeof(data.Unknown4));
            for (size_t k = 0; k < data.WeaponBonesCount; k++) {
                model.read((char*)&data.WeaponBones[k].WeaponBoneName, sizeof(data.WeaponBones[k].WeaponBoneName));
                model.read((char*)&data.WeaponBones[k].Unknown5, sizeof(data.WeaponBones[k].Unknown5));
                model.read((char*)&data.WeaponBones[k].WeaponBoneID, sizeof(data.WeaponBones[k].WeaponBoneID));
            }
            for (size_t k = 0; k < data.TexturesCount; k++) {
                model.read((char*)&TD, sizeof(TD));
                data.TexData.push_back(TD);
            }
            model.read((char*)&data.NullMask, sizeof(data.NullMask));
            if (data.rigid_material_ID == 79) {
                model.read((char*)&data.ShaderParams.DetailTileU, sizeof(data.ShaderParams.DetailTileU));
                model.read((char*)&data.ShaderParams.Unknown7, sizeof(data.ShaderParams.Unknown7));
                model.read((char*)&data.ShaderParams.DetailTileV, sizeof(data.ShaderParams.DetailTileV));
                model.read((char*)&data.ShaderParams.Unknown8, sizeof(data.ShaderParams.Unknown8));
                model.read((char*)&data.ShaderParams.DirtTileU, sizeof(data.ShaderParams.DirtTileU));
                model.read((char*)&data.ShaderParams.Unknown9, sizeof(data.ShaderParams.Unknown9));
                model.read((char*)&data.ShaderParams.DirtTileV, sizeof(data.ShaderParams.DirtTileV));
                model.read((char*)&data.ShaderParams.Unknown10, sizeof(data.ShaderParams.Unknown10));
            }
            model.read((char*)&data.AlphaMode, sizeof(data.AlphaMode));
            for (size_t k = 0; k < data.VerticesCount[j]; k++) {
                model.read((char*)&vertex, sizeof(vertex));
                geometry.Vertices.push_back(vertex);
            }
            for (size_t k = 0; k < data.IndicesCount[j] / 3; k++) {
                model.read((char*)&index, sizeof(index));
                geometry.Indices.push_back(index);
            }
            data.Mesh.push_back(geometry);
            geometry = {};
        }
        rmv2.lod.push_back(data);
        data = {};
    }
    model.close();
}

void to_rmv2(RMV2 &rmv2, char filename[128]) {
    ofstream model(filename, ios::out | ios::binary);
    model.write((char*)&rmv2, 140);

    for (size_t i = 0; i < rmv2.LodsCount; i++) {
        model.write((char*)&rmv2.GroupsCount[i], sizeof(uint32_t));
        model.write((char*)&rmv2.VDCount[i], sizeof(uint32_t));
        model.write((char*)&rmv2.IDCount[i], sizeof(uint32_t));
        model.write((char*)&rmv2.StartOffset[i], sizeof(uint32_t));
        model.write((char*)&rmv2.ZoomFactor[i], sizeof(float));
    }
    for (size_t i = 0; i < rmv2.LodsCount; i++) {
        for (size_t j = 0; j < rmv2.GroupsCount[i]; j++) {
            model.write((char*)&rmv2.lod[i].rigid_material_ID, sizeof(rmv2.lod[i].rigid_material_ID));
            model.write((char*)&rmv2.lod[i].LodSize[j], sizeof(rmv2.lod[i].LodSize[j]));
            model.write((char*)&rmv2.lod[i].LodVerticesOffset[j], sizeof(rmv2.lod[i].LodVerticesOffset[j]));
            model.write((char*)&rmv2.lod[i].VerticesCount[j], sizeof(rmv2.lod[i].VerticesCount[j]));
            model.write((char*)&rmv2.lod[i].LodIndicesOffset[j], sizeof(rmv2.lod[i].LodIndicesOffset[j]));
            model.write((char*)&rmv2.lod[i].IndicesCount[j], sizeof(rmv2.lod[i].IndicesCount[j]));
            model.write((char*)&rmv2.lod[i].GroupMinX[j], sizeof(rmv2.lod[i].GroupMinX[j]));
            model.write((char*)&rmv2.lod[i].GroupMinY[j], sizeof(rmv2.lod[i].GroupMinY[j]));
            model.write((char*)&rmv2.lod[i].GroupMinZ[j], sizeof(rmv2.lod[i].GroupMinZ[j]));
            model.write((char*)&rmv2.lod[i].GroupMaxX[j], sizeof(rmv2.lod[i].GroupMaxX[j]));
            model.write((char*)&rmv2.lod[i].GroupMaxY[j], sizeof(rmv2.lod[i].GroupMaxY[j]));
            model.write((char*)&rmv2.lod[i].GroupMaxZ[j], sizeof(rmv2.lod[i].GroupMaxZ[j]));
            model.write((char*)&rmv2.lod[i].ShaderMaterial, sizeof(rmv2.lod[i].ShaderMaterial));
            model.write((char*)&rmv2.lod[i].Unknown1, sizeof(rmv2.lod[i].Unknown1));
            model.write((char*)&rmv2.lod[i].Unknown2, sizeof(rmv2.lod[i].Unknown2));
            model.write((char*)&rmv2.lod[i].GroupName[j], sizeof(rmv2.lod[i].GroupName[j]));
            model.write((char*)&rmv2.lod[i].TexturesDir, sizeof(rmv2.lod[i].TexturesDir));
            model.write((char*)&rmv2.lod[i].Unknown3, sizeof(rmv2.lod[i].Unknown3));
            model.write((char*)&rmv2.lod[i].WeaponBonesCount, sizeof(rmv2.lod[i].WeaponBonesCount));
            model.write((char*)&rmv2.lod[i].TexturesCount, sizeof(rmv2.lod[i].TexturesCount));
            model.write((char*)&rmv2.lod[i].Unknown4, sizeof(rmv2.lod[i].Unknown4));
            for (size_t k = 0; k < rmv2.lod[i].WeaponBonesCount; k++) {
                model.write((char*)&rmv2.lod[i].WeaponBones[k], sizeof(rmv2.lod[i].WeaponBones[k]));
            }
            for (size_t k = 0; k < rmv2.lod[i].TexturesCount; k++) {
                model.write((char*)&rmv2.lod[i].TexData[k], sizeof(rmv2.lod[i].TexData[k]));
            }
            model.write((char*)&rmv2.lod[i].NullMask, sizeof(rmv2.lod[i].NullMask));
            if (rmv2.lod[i].rigid_material_ID == 79) {
                model.write((char*)&rmv2.lod[i].ShaderParams.DetailTileU, sizeof(rmv2.lod[i].ShaderParams.DetailTileU));
                model.write((char*)&rmv2.lod[i].ShaderParams.Unknown7, sizeof(rmv2.lod[i].ShaderParams.Unknown7));
                model.write((char*)&rmv2.lod[i].ShaderParams.DetailTileV, sizeof(rmv2.lod[i].ShaderParams.DetailTileV));
                model.write((char*)&rmv2.lod[i].ShaderParams.Unknown8, sizeof(rmv2.lod[i].ShaderParams.Unknown8));
                model.write((char*)&rmv2.lod[i].ShaderParams.DirtTileU, sizeof(rmv2.lod[i].ShaderParams.DirtTileU));
                model.write((char*)&rmv2.lod[i].ShaderParams.Unknown9, sizeof(rmv2.lod[i].ShaderParams.Unknown9));
                model.write((char*)&rmv2.lod[i].ShaderParams.DirtTileV, sizeof(rmv2.lod[i].ShaderParams.DirtTileV));
                model.write((char*)&rmv2.lod[i].ShaderParams.Unknown10, sizeof(rmv2.lod[i].ShaderParams.Unknown10));
            }
            model.write((char*)&rmv2.lod[i].AlphaMode, sizeof(rmv2.lod[i].AlphaMode));
            for (size_t k = 0; k < rmv2.lod[i].VerticesCount[j]; k++) {
                model.write((char*)&rmv2.lod[i].Mesh[j].Vertices[k], sizeof(rmv2.lod[i].Mesh[j].Vertices[k]));
            }
            for (size_t k = 0; k < rmv2.lod[i].IndicesCount[j] / 3; k++) {
                model.write((char*)&rmv2.lod[i].Mesh[j].Indices[k], sizeof(rmv2.lod[i].Mesh[j].Indices[k]));
            }
        }
    }
    model.close();
}

struct DAE {
    vector<char> Signature;
};

void convert(RMV2 &rmv2, DAE &dae) {
//  dae.Signature[0] = "<?xml version='1.0' encoding='utf - 8'?>";
}

void to_dae(DAE &dae, char filename[128]) {
    ofstream model(filename, ios::out | ios::binary);
    model.write((char*)&dae, 140);
    model.close();
}

int main(int argc, char *argv[])
{
    RMV2 rmv2;
    DAE dae;
    char filename[128], daeFilename[128];

    cout << "Filename: ";
    gets_s(filename, sizeof(filename));
    strcpy_s(daeFilename, filename);
    strcat_s(filename, ".rigid_model_v2");
    strcat_s(daeFilename, ".dae");

    read(rmv2,  filename);
    convert(rmv2, dae);
    to_dae(dae, daeFilename);
//  to_rmv2(rmv2, daeFilename);

//  cout << rmv2.lod[0].Mesh[0].Vertices[0].X << endl;
    cout << "Successfully converted to .dae" << endl;
    system("pause");
    return 0;
}

这是我的 C# 尝试:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace RMV2Convertor
{
    public partial class ConvertorForm : Form
    {
        public ConvertorForm()
        {
            InitializeComponent();
        }

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        struct Group
        {
            public Group(int size = 32)
            {
                sbyte[] Name = new sbyte[size];
            }
        };
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        struct WeaponBonesData
        {
            sbyte[] WeaponBoneName;
            sbyte[] Unknown5;
            uint WeaponBoneID;
            public WeaponBonesData(int size = 32)
            {
                WeaponBoneName = new sbyte[size];
                Unknown5 = new sbyte[48];
                WeaponBoneID = new uint();
            }
        }
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        struct TexturesData
        {
            uint TextureType;
            sbyte[] TextureName;
            public TexturesData(int size = 256)
            {
                TextureType = new uint();
                TextureName = new sbyte[size];
            }
        };
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        struct Shader
        {
            float DetailTileU;
            uint Unknown7;
            float DetailTileV;
            uint Unknown8;
            uint DirtTileU;
            uint Unknown9;
            uint DirtTileV;
            uint Unknown10;
        };
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        struct VertexData
        {
            Half X;
            Half Y;
            Half Z;
            Half Sep1;
            bool bone0;
            bool bone1;
            bool weight;
            bool Sep2;
            bool normX;
            bool normY;
            bool normZ;
            bool Sep3;
            Half U;
            Half V;
            ulong Unknown11;
        };
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        struct IndexData
        {
            ushort ind1;
            ushort ind2;
            ushort ind3;
        };
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        struct Geometry
        {
            List<VertexData> Vertices;
            List<IndexData> Indices;
        };
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        struct rigid_model
        {
            uint rigid_material_ID;
            List<uint> LodSize;
            List<uint> LodVerticesOffset;
            List<uint> VerticesCount;
            List<uint> LodIndicesOffset;
            List<uint> IndicesCount;
            List<float> GroupMinX;
            List<float> GroupMinY;
            List<float> GroupMinZ;
            List<float> GroupMaxX;
            List<float> GroupMaxY;
            List<float> GroupMaxZ;
            sbyte[] ShaderMaterial;
            sbyte[] Unknown1;
            ushort Unknown2;
            List<Group> GroupName;
            sbyte[] TexturesDir;
            sbyte[] Unknown3;
            uint WeaponBonesCount;
            uint TexturesCount;
            sbyte[] Unknown4;
            WeaponBonesData[] WeaponBones;
            List<TexturesData> TexData;
            uint NullMask;
            Shader ShaderParams;
            uint AlphaMode;
            List<Geometry> Mesh;
            public rigid_model(int size = 12)
            {
                rigid_material_ID = new uint();
                LodSize = new List<uint>();
                LodVerticesOffset = new List<uint>();
                VerticesCount = new List<uint>();
                LodIndicesOffset = new List<uint>();
                IndicesCount = new List<uint>();
                GroupMinX = new List<float>();
                GroupMinY = new List<float>();
                GroupMinZ = new List<float>();
                GroupMaxX = new List<float>();
                GroupMaxY = new List<float>();
                GroupMaxZ = new List<float>();
                ShaderMaterial = new sbyte[size];
                Unknown1 = new sbyte[20];
                Unknown2 = new ushort();
                GroupName = new List<Group>();
                TexturesDir = new sbyte[256];
                Unknown3 = new sbyte[422];
                WeaponBonesCount = new uint();
                TexturesCount = new uint();
                Unknown4 = new sbyte[140];
                WeaponBones = new WeaponBonesData[5];
                TexData = new List<TexturesData>();
                NullMask = new uint();
                ShaderParams = new Shader();
                AlphaMode = new uint();
                Mesh = new List<Geometry>();
            }
        };
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        struct RMV2
        {
            public char[] Signature;
            public uint ModelType;
            public uint LodsCount;
            public char[] SkeletonName;
            public List<uint> GroupsCount;
            public List<uint> VDCount;
            public List<uint> IDCount;
            public List<uint> StartOffset;
            public List<float> ZoomFactor;
            public List<rigid_model> lod;
            public RMV2(int size = 4)
            {
                Signature = new char[size];
                ModelType = new uint();
                LodsCount = new uint();
                SkeletonName = new char[128];
                GroupsCount = new List<uint>();
                VDCount = new List<uint>();
                IDCount = new List<uint>();
                StartOffset = new List<uint>();
                ZoomFactor = new List<float>();
                lod = new List<rigid_model>();
            }
        };

        void read(RMV2 rmv2, string filename)
        {
            using (BinaryReader model = new BinaryReader(File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read), Encoding.ASCII))
            {
                rmv2.Signature = model.ReadChars(4);
            }
            MessageBox.Show(rmv2.Signature.ToString());
        }

        private void bOpenFileDialog_Click(object sender, EventArgs e)
        {
            Stream myStream = null;
            OpenFileDialog openFileDialog1 = new OpenFileDialog();

            openFileDialog1.InitialDirectory = "c:\\";
            openFileDialog1.Filter = "rigid_model_v2 files (*.rigid_model_v2)|*.rigid_model_v2|All files (*.*)|*.*";
            openFileDialog1.FilterIndex = 1;
            openFileDialog1.RestoreDirectory = true;


            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {
                try
                {
                    if ((myStream = openFileDialog1.OpenFile()) != null)
                    {
                        using (myStream)
                        {
                            RMV2 rmv2 = new RMV2();
                            string filename = openFileDialog1.FileName;
                            read(rmv2, filename);
                        }
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Error: Could not read file from disk. Original error: " + ex.Message);
                }
            }
        }
    }
}

所以我需要一个最重要的问题的解决方案:如何读取二进制文件进行结构化？

最佳答案

要读取文件，只需调用 ReadAllBytes:

byte[] array = File.ReadAllBytes("file path");

您可以在您的结构中定义相应的属性。

关于c# - 写一个二进制文件到struct c#，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39555461/

文章推荐： c++ - 如何使用 GLSL 在体积渲染中进行混合？

文章推荐： c++ - QTest 获取测试名称

c++ - 是否不可能在 QdataStream 为 float 写 4 个字节，为 double 写 8 个字节？
我需要(我必须)将大量 float 写入 qdatastream 并且我只使用 4 个字节是必要的。setFloatingPointPrecision 或为 float 和 double 写入 4 或
Python和C文件同时读/写
我有一些 C 代码，我用 Python 对其进行了扩展。扩展的 C 代码有一个将一些结构附加到二进制文件的函数: void writefunction(const struct struct1* so
写/读文件冲突
我正在用 C 语言开发一个小软件，用于在布告栏中读取和写入消息。每条消息都是一个以渐进数字命名的 .txt。软件是多线程的，有很多用户可以并发操作。用户可以进行的操作有: 阅读整个公告板(所有 .
java内存映射文件多线程读/写
我有 2 个线程同时访问同一个大文件 (.txt)。第一个线程正在从文件中读取。第二个线程正在写入文件。两个线程都访问同一个 block ，例如(开始:0， block 大小:10)，但具有不同的
linux剪贴板在C中读/写
我做了很多谷歌搜索，但我仍然不确定如何继续。 Linux 下最常见的剪贴板读写方式是什么？我想要同时支持 Gnome 和 KDE 桌面。更新:我是否认为没有简单的解决方案，必须将多个来源(gnome
写 Java 代码的14个好习惯
1. 定义配置文件信息有时候我们为了统一管理会把一些变量放到 yml 配置文件中例如图片用 @ConfigurationProperties 代替 @Value 使用方法定义对应字段的实体
io - FORTRAN 写()
在开始之前，我必须先声明我是 FORTRAN 的新手。我正在维护 1978 年的一段遗留代码。它的目的是从文件中读取一些数据值，处理这些值，然后将处理过的值输出到另一个文本文件。给定以下 FORTR
iPhone读/写.plist文件
我正在制作一个应用程序，我需要存储用户提供的一些信息。我尝试使用 .plist 文件来存储信息，我发现: NSString *filePath = @"/Users/Denis/Documents/X
Delphi 属性读/写
在delphi类中声明属性时是否可能有不同类型的结果？示例: 属性月份:字符串读取monthGet(字符串)写入monthSet(整数); 在示例中，我希望在属性(property)月份中，当我:读
delphi - delphi中的文件快速读/写
我正在以二进制形式将文件加载到数组中，这似乎需要一段时间有没有更好更快更有效的方法来做到这一点。我正在使用类似的方法写回文件。 procedure openfile(fname:string); va
c# - 如何使用线程在控制台上同时进行读/写
我想实现一个运行模拟的C#控制台应用程序。另外，我想给用户机会在控制台上按“+”或“-”来加速/减速模拟的速度。有没有办法在编写控制台时读取控制台？我相信我可以为此使用多线程，但是我却不怎么做(我对
rust - 写!引用时宏不会在单独的方法中编译
这是我的代码: use std::fs::File; use std::io::Write; fn main() { let f = File::create("").unwrap();
java - 在哪里以及如何存储文本文件以供读/写
我有一个应用程序可以访问 csv 文本文件中的单词。由于它们通常不会更改，因此我将它们放置在 .jar 文件中，并使用 .getResourceAsStream 调用读取它们。我真的很喜欢这种方法，因
security - 为什么Kubernetes允许在kubelet目录中进行全局读/写？
我使用kubeadm，docker 17.12.1-ce和法兰绒网络安装了Kubernetes 1.13.1集群但是，我发现Kubernetes主服务器上有许多空文件，权限为666，该文件允许任何用
Java - 文件读/写
我的工作区中有一些 java 文件。现在我想编写一个java程序，它可以读取来自不同源的文本文件，一次一个，一行一行，并将这些行插入到工作区中各自的java文件中。文本文件会告诉我将哪个文件插入到哪
filesystems - 文件系统如何处理并发读/写？
用户A要求系统读取文件foo，同时用户B想要将他或她的数据保存到同一个文件中。在文件系统级别如何处理这种情况？最佳答案大多数文件系统(但不是全部)使用锁定来保护对同一文件的并发访问。锁可以是独占的
android - 如何防止黑客在firebase数据库上读/写
我对保护移动应用程序的 firebase 数据库有一些疑问。例如，在反编译Android应用程序后，黑客可以获取firebase api key 然后访问firebase数据库，这是正确的吗？假设
java - 使用java创建不可删除的文件并对其进行读/写
我想让文件从外部不可删除，并希望使用java从程序对该文件进行读/写操作。 S0，我使用以下代码使用java创建了不可删除的文件: Process pcs = Runtime.getRunti
java NIO独立读/写
当 Selector.select() 以阻塞模式等待读/写操作时，是否可以将写消息推送到客户端？如何将选择器从阻塞模式移至写入模式？触发器可以是一个后台线程，用于放置需要写入给定 channel 的
c - 多个子进程在同一管道上读/写
我目前正在学习在 Linux 环境中使用 C 进行套接字编程。作为一个项目，我正在尝试编写一个基本的聊天服务器和客户端。目的是让服务器为每个连接的客户端派生一个进程。我遇到的问题是读取一个 chi

塔克拉玛干

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c# - 写一个二进制文件到struct c#