加密逗号分隔的 ID 列表是否会使其更小以适合 cookie？

Question

假设我想将 ID 存储在 cookie 中：

123,1232,3443,2343,2344422,2342

看到 cookie 有 4kb 限制（或其他），加密该值是否会以某种方式允许更多存储？

如果是这样，哪种加密最好？ （并不是真的担心安全，只是想用更少的空间存储更多内容）

Answer 1

4k字节可以存储819个四位数。您确定您真的需要存储更多吗？

在 cookie 中存储一个密钥，通过简单的数据库查询即可找到超长的数字序列，这不是更容易吗？

Answer 2

加密本身不会压缩数据。不过你可以考虑压缩它。请记住，不同的值会压缩不同的量，因此，如果您接近可压缩的限制，您可能会发现它有时不合适。如果您的空间不足，您可能需要寻找不同的方法。

请注意，加密后您无法对其进行有意义的压缩。加密将其变成看似随机的数据，并且不适合压缩。

Answer 3

加密不一定会压缩（通常不会），并且您所做的任何压缩都可以在不加密的情况下完成。

我可以建议您查看协议缓冲区，以找到一种有效存储此类简单数据的简单方法。

Answer 4

如果您只对压缩数据感兴趣，您可以使用 .Net 中的流压缩类。 http://msdn.microsoft.com/en-我们/library/system.io.compression.gzipstream.aspx

Answer 5

您可以使用 VInt/Vlong 的实现对每个数字尝试进行小压缩。压缩会根据您的数据而有所不同。内径越高，压缩率越低。

这是使用 Vint 的实现：

class CookieConverter
{
    private readonly Encoding _enc = Encoding.GetEncoding("iso-8859-1");
    public string PackCookieString(List<int> numbers)
    {
        MemoryStream memoryStream = new MemoryStream();
        foreach (int number in numbers)
        {
            byte[] bytes = GetVIntBytes(number);
            memoryStream.Write(bytes, 0, bytes.Length);
        }
        return _enc.GetString(memoryStream.ToArray());
    }

    public List<int> UnpackCookieString(string cookie)
    {
        byte[] bytes = _enc.GetBytes(cookie);
        List<int> numbers = new List<int>();
        int startIndex = 0;
        while (startIndex < bytes.Length)
        {
            numbers.Add(GetVInt(bytes, ref startIndex));
        }
        return numbers;
    }

    public byte[] GetVIntBytes(int value)
    {
        byte[] buffer = new byte[5];
        byte length = 0;
        while ((value & ~0x7F) != 0)
        {
            buffer[length] = (byte) ((value & 0x7f) | 0x80);
            value = value >> 7;
            length++;
        }
        buffer[length] = (byte) value;
        byte[] result = new byte[length+1];
        Array.Copy(buffer, 0, result, 0, result.Length);
        return result;
    }

    public int GetVInt(byte[] buffer, ref int startIndex)
    {
        byte b = buffer[startIndex];
        startIndex++;
        int i = b & 0x7F;
        for (int shift = 7; (b & 0x80) != 0; shift += 7)
        {
            b = buffer[startIndex];
            i |= (b & 0x7F) << shift;
            startIndex++;
        }
        return i;
    }