C# linq 表达式。如何获得不同的偏移量和“任何”偏移量？

Question

我想读出文件的标题并将其与给定的签名进行比较。签名的开头可以有一个偏移量。

这是我目前的功能：

    public FileTypeVerifyResult Verify(Stream stream)
    {
        stream.Position = 0;
        var reader = new BinaryReader(stream);
        var headerBytes = reader.ReadBytes(SignatureLength + this.OffSet);

        return new FileTypeVerifyResult
        {
            Name = Name,
            Description = Description,
            IsVerified = Signatures.Any(signature =>
                headerBytes.Skip(this.OffSet).Take(signature.Length)
                    .SequenceEqual(signature)
            )
        };
    }

这目前适用于一个偏移量，但存在可以具有多个偏移量的扩展。所以我的第一个想法是使OffSet 属性成为具有所有偏移量的int[]，但是我不知道这是否可以轻松地构建到这个 linq 表达式中。

此外，文件可以具有偏移量any（或任何其他表示文件中任何位置的值，例如-1）。怎么会有这样的东西？

Answer 1

为了能够处理更多的偏移，这是我的解决方案：

    protected List<int> OffSets { get; set; }

    public int OffSetLength => OffSets.Max(m => m);

    public FileTypeVerifyResult Verify(Stream stream)
    {
        stream.Position = 0;
        var reader = new BinaryReader(stream);
        var headerBytes = reader.ReadBytes(SignatureLength + OffSetLength);
        reader.Close();

        return new FileTypeVerifyResult
        {
            Name = Name,
            Description = Description,
            IsVerified = Signatures.Any(signature =>
                OffSets.Any(offSet => 
                    headerBytes.Skip(offSet).Take(signature.Length)
                        .SequenceEqual(signature))
            )
        };
    }

如果不重写所有内容，我认为我无法在此函数中获得 any/-1 偏移量。

Answer 2

我认为这是瑞士刀不是你想要的情况，Linq 对很多事情都有好处，但它确实没有为手头的问题增加任何价值，恕我直言，因为编写这样的查询会让人眼前一亮流血，但这是我对问题本身的看法，如果有的话，很少使用 LINQ :)

我允许自己扣除未提供的缺失项目并合理命名。

public class FileType
{
    public class FileTypeVerifyResult
    {
        public string Name { get; set; }
        public string Description { get; set; }
        public bool IsVerified { get; set; }
    }

    public class Signature
    {
        /// <summary>
        /// Actual signature
        /// </summary>
        public byte[] Payload { get; set; }
        public int Length { get => Payload.Length; }
        public List<int> OffSets { get; set; }
    }
    
    public string Name { get; set; }
    public string Description { get; set; }

    public List<Signature> Signatures { get; set; }

    public FileTypeVerifyResult Verify(Stream stream)
    {
        if (stream == null) throw new ArgumentException(nameof(stream));
        if(stream.CanSeek)
            stream.Position = 0;
        else
            //TODO: Consider if we need this: throw new ArgumentException("Stream does not support seek", nameof(stream));
        
        var bytes = new byte[stream.Length];
        int wasRead = stream.Read(bytes, 0, (int)stream.Length);
        if (wasRead == 0) throw new ArgumentException("Unable to read from stream");
        
        foreach (var signature in Signatures)
        {
            foreach(var offset in signature.OffSets)
            {
                if(offset == -1)
                {
                    //TODO: read signature length from each position first 0, then 1 until what is left is less than length of signature and if it fits
                    return createResultObject(true);
                }

                var candidateBytes = new byte[signature.Length];
                candidateBytes = bytes.Skip(offset).Take(signature.Length).ToArray();
                //  I'd not use linq, instead  Array.Copy(bytes, offset, candidateBytes, 0, signature.Length);
                if(signature.Payload.Equals(candidateBytes))                    
                {
                    return createResultObject(true);    
                }
            }                
        }
        return createResultObject();

        FileTypeVerifyResult createResultObject(bool isValid = false)
        {
            return new FileTypeVerifyResult
            {
                Name = Name,
                Description = Description,
                IsVerified = isValid
            };
        }
    }
}