Javascript LZMA-JS压缩的C#等价_Javascript_C#_Compression

Javascript LZMA-JS压缩的C#等价

javascript c# compression

Javascript LZMA-JS压缩的C#等价,javascript,c#,compression,Javascript,C#,Compression,我使用了一些客户端javscript代码来压缩一些用户输入。在后端代码中，我使用中的代码示例使用C#解压数据服务器端这台机器运转得很好现在我希望能够像javascript一样压缩字符串。当我使用压缩代码时，我得到一个从-128到128的有符号整数数组。现在我想用我的后端代码来做同样的事情 javascript中的LMZA属性与C#代码中的默认属性略有不同，但即使我将它们更改为相同的值，我也会从两个库中得到不同的结果首先，C代码的输出值是无符号的。其次，返回的字符数不同。这些差异可能是

我使用了一些客户端javscript代码来压缩一些用户输入。在后端代码中，我使用中的代码示例使用C#解压数据服务器端

这台机器运转得很好

现在我希望能够像javascript一样压缩字符串。当我使用压缩代码时，我得到一个从-128到128的有符号整数数组。现在我想用我的后端代码来做同样的事情

javascript中的LMZA属性与C#代码中的默认属性略有不同，但即使我将它们更改为相同的值，我也会从两个库中得到不同的结果

首先，C代码的输出值是无符号的。其次，返回的字符数不同。这些差异可能是由解码器的属性引起的，但我不知道如何使这两个库对齐

我的C#使用from 7zip

我的C#代码用于解压缩javascript压缩数据（以逗号分隔的有符号整数数组）：

公共静态无效解压缩（流内流、流外流）
{
字节[]属性=新字节[5]；
流内读取（属性，0,5）；
SevenZip.Compression.LZMA.Decoder解码器=新的SevenZip.Compression.LZMA.Decoder（）；
解码器.SetDecoderProperties（属性）；
长超尺寸=0；
对于（int i=0；i<8；i++）
{
int v=inStream.ReadByte（）；
超大|=（（长）（字节）v）（字节）int.Parse（s））；
var stream=新的内存流（myint）；
var outputStream=new MemoryStream（）；
解压缩（流、输出流）；
使用（var reader=newstreamreader（outputStream））
{
outputStream.Position=0；
字符串输出=reader.ReadToEnd（）；
返回输出；
}
}
返回“”；
}

压缩数据的代码如下（字节数不同且无符号）：

publicstaticstringcompresslzma（stringinputstring）
{
如果（！string.IsNullOrEmpty（inputstring））
{               
var stream=newmemoryStream（Encoding.Unicode.GetBytes（inputstring？？））；
var outputStream=new MemoryStream（）；
压缩（流、输出流）；
byte[]bytes=outputStream.ToArray（）；
}
返回“”；
}
公共静态无效压缩（内存流内流、内存流外流）
{
CoderPropID[]PROPID；
对象[]属性；
制备编码器（输出PROPID，输出属性）；
SevenZip.Compression.LZMA.Encoder编码器=新的SevenZip.Compression.LZMA.Encoder（）；
编码器.SetCoderProperties（PROPID、属性）；
编码器。WriteCodeProperties（超出流）；
Int64 fileSize=inStream.Length；
对于（int i=0；i<8；i++）
{
outStream.WriteByte（（字节）（文件大小>>（8*i））；
}
编码器代码（流内，流外，-1，-1，空）；
}
公共静态void PrepareEncoder（out CoderPropID[]PROPID，out object[]属性）
{
布尔状态方程=真；
Int32 dictionary=1此代码用于创建与javascript代码相同的字符串，包括LMZA设置：
public static string CompressLzma(string inputstring)
{
    if (!string.IsNullOrEmpty(inputstring))
    {
        var stream = new MemoryStream(Encoding.UTF8.GetBytes(inputstring ?? ""));
        var outputStream = new MemoryStream();
        Compress(stream, outputStream);


        byte[] bytes = outputStream.ToArray();
        var result = string.Join(",", Array.ConvertAll(bytes, v => signedInt((int)v)));
        return result;
    }

    return "";
}


public static void PrepareEncoder(out CoderPropID[] propIDs, out object[] properties)
{
    bool eos = true;
    Int32 dictionary = 1 << 16;
    Int32 posStateBits = 2;
    Int32 litContextBits = 3; // for normal files
    // UInt32 litContextBits = 0; // for 32-bit data
    Int32 litPosBits = 0;
    // UInt32 litPosBits = 2; // for 32-bit data
    Int32 algorithm = 2;
    Int32 numFastBytes = 64;
    string mf = "bt4";

    propIDs = new CoderPropID[]
    {
       CoderPropID.DictionarySize,
       CoderPropID.PosStateBits,
       CoderPropID.LitContextBits,
       CoderPropID.LitPosBits,
       CoderPropID.Algorithm,
       CoderPropID.NumFastBytes,
       CoderPropID.MatchFinder,
       CoderPropID.EndMarker
    };
    properties = new object[]
    {
       dictionary,
       posStateBits,
       litContextBits,
       litPosBits,
       algorithm,
       numFastBytes,
       mf,
       eos
    };
}

private static int signedInt(int unsignedInt)
{
    return unsignedInt >= 128 ? Math.Abs(128 - unsignedInt) - 128 : unsignedInt;
}


public static void Compress(MemoryStream inStream, MemoryStream outStream)
{
    CoderPropID[] propIDs;
    object[] properties;
    PrepareEncoder(out propIDs, out properties);

    SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
    encoder.SetCoderProperties(propIDs, properties);
    encoder.WriteCoderProperties(outStream);
    Int64 fileSize = inStream.Length;
    for (int i = 0; i < 8; i++)
    {
        outStream.WriteByte((Byte)(fileSize >> (8 * i)));
    }
    encoder.Code(inStream, outStream, -1, -1, null);
}

publicstaticstringcompresslzma（stringinputstring）
{
如果（！string.IsNullOrEmpty（inputstring））
{
var stream=newmemoryStream（Encoding.UTF8.GetBytes（inputstring？？？）；
var outputStream=new MemoryStream（）；
压缩（流、输出流）；
byte[]bytes=outputStream.ToArray（）；
var result=string.Join（“，”，Array.ConvertAll（bytes，v=>signedInt（（int）v））；
返回结果；
}
返回“”；
}
公共静态void PrepareEncoder（out CoderPropID[]PROPID，out object[]属性）
{
布尔状态方程=真；
Int32 dictionary=1=128？Math.Abs（128-unsignedInt）-128:unsignedInt；
}
公共静态无效压缩（内存流内流、内存流外流）
{
CoderPropID[]PROPID；
对象[]属性；
制备编码器（输出PROPID，输出属性）；
SevenZip.Compression.LZMA.Encoder编码器=新的SevenZip.Compression.LZMA.Encoder（）；
编码器.SetCoderProperties（PROPID、属性）；
编码器。WriteCodeProperties（超出流）；
Int64 fileSize=inStream.Length；
对于（int i=0；i<8；i++）
{
outStream.WriteByte（（字节）（文件大小>>（8*i））；
}
编码器代码（流内，流外，-1，-1，空）；
}
尝试使用编码。UTF8
而不是编码。UnicodeUTF8确实如此，我假设javascript编码是UTF16，没有尝试UTF8编码，将所有字节转换为有符号整数后，输出完全相同
public static string CompressLzma(string inputstring)
{
    if (!string.IsNullOrEmpty(inputstring))
    {               
        var stream = new MemoryStream(Encoding.Unicode.GetBytes(inputstring ?? ""));
        var outputStream = new MemoryStream();
        Compress(stream, outputStream);



        byte[] bytes = outputStream.ToArray();


    }

    return "";
}

public static void Compress(MemoryStream inStream, MemoryStream outStream)
{
    CoderPropID[] propIDs;
    object[] properties;
    PrepareEncoder(out propIDs, out properties);

    SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
    encoder.SetCoderProperties(propIDs, properties);
    encoder.WriteCoderProperties(outStream);
    Int64 fileSize = inStream.Length;
    for (int i = 0; i < 8; i++)
    {
        outStream.WriteByte((Byte)(fileSize >> (8 * i)));
    }
    encoder.Code(inStream, outStream, -1, -1, null);
}

public static void PrepareEncoder(out CoderPropID[] propIDs, out object[] properties)
{
    bool eos = true;
    Int32 dictionary = 1 << 16;
    Int32 posStateBits = 2;
    Int32 litContextBits = 3; // for normal files
    // UInt32 litContextBits = 0; // for 32-bit data
    Int32 litPosBits = 0;
    // UInt32 litPosBits = 2; // for 32-bit data
    Int32 algorithm = 2;
    Int32 numFastBytes = 32;
    string mf = "bt2";

    propIDs = new CoderPropID[]
    {
        CoderPropID.DictionarySize,
        CoderPropID.PosStateBits,
        CoderPropID.LitContextBits,
        CoderPropID.LitPosBits,
        CoderPropID.Algorithm,
        CoderPropID.NumFastBytes,
        CoderPropID.MatchFinder,
        CoderPropID.EndMarker
    };
    properties = new object[]
    {
        dictionary,
        posStateBits,
        litContextBits,
        litPosBits,
        algorithm,
        numFastBytes,
        mf,
        eos
    };
}

public static string CompressLzma(string inputstring)
{
    if (!string.IsNullOrEmpty(inputstring))
    {
        var stream = new MemoryStream(Encoding.UTF8.GetBytes(inputstring ?? ""));
        var outputStream = new MemoryStream();
        Compress(stream, outputStream);


        byte[] bytes = outputStream.ToArray();
        var result = string.Join(",", Array.ConvertAll(bytes, v => signedInt((int)v)));
        return result;
    }

    return "";
}


public static void PrepareEncoder(out CoderPropID[] propIDs, out object[] properties)
{
    bool eos = true;
    Int32 dictionary = 1 << 16;
    Int32 posStateBits = 2;
    Int32 litContextBits = 3; // for normal files
    // UInt32 litContextBits = 0; // for 32-bit data
    Int32 litPosBits = 0;
    // UInt32 litPosBits = 2; // for 32-bit data
    Int32 algorithm = 2;
    Int32 numFastBytes = 64;
    string mf = "bt4";

    propIDs = new CoderPropID[]
    {
       CoderPropID.DictionarySize,
       CoderPropID.PosStateBits,
       CoderPropID.LitContextBits,
       CoderPropID.LitPosBits,
       CoderPropID.Algorithm,
       CoderPropID.NumFastBytes,
       CoderPropID.MatchFinder,
       CoderPropID.EndMarker
    };
    properties = new object[]
    {
       dictionary,
       posStateBits,
       litContextBits,
       litPosBits,
       algorithm,
       numFastBytes,
       mf,
       eos
    };
}

private static int signedInt(int unsignedInt)
{
    return unsignedInt >= 128 ? Math.Abs(128 - unsignedInt) - 128 : unsignedInt;
}


public static void Compress(MemoryStream inStream, MemoryStream outStream)
{
    CoderPropID[] propIDs;
    object[] properties;
    PrepareEncoder(out propIDs, out properties);

    SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
    encoder.SetCoderProperties(propIDs, properties);
    encoder.WriteCoderProperties(outStream);
    Int64 fileSize = inStream.Length;
    for (int i = 0; i < 8; i++)
    {
        outStream.WriteByte((Byte)(fileSize >> (8 * i)));
    }
    encoder.Code(inStream, outStream, -1, -1, null);
}