C# 泛型 - 无法将 'byte[]' 转换为 'T'

Question

在 C# 中使用泛型类和方法时，我需要您的帮助。当我在ProduceData中调用EnqueObject方法时，在EnqueueObject(block)那一行，出现错误：cannot convert 'byte[ ]' 到 'T'。如有任何建议，我将不胜感激。

（我已经简化了我的代码，因为我相信我的问题是非常基本的）。

class CompressingProducer<T>
{
    Queue<T> _queue;

    public void ProduceData(object fileInputStream)
    {
        byte[] block = new byte[Settings.blockSize];
        int bytesRead;

        while ((bytesRead = ((Stream)fileInputStream).Read(block, 0, Settings.blockSize)) > 0)     
        {
            EnqueueObject(block);   
            block = new byte[Settings.blockSize];
        }
    }

    private void EnqueueObject(T data) 
    {
        _queue.Enqueue(data);
    }
}

---

更新

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.IO;

namespace GZipTestProject
{
    class CompressingProducer<T>
    {           
        Thread _producerThread;
        readonly object _lock;
        Queue<T> _queue;

        /// <summary>
        /// Reads data in chunks (as byte[]) or as CompressedData objects from the file stream and inserts them into a queue
        /// </summary>
        /// <param name="fileInputStream">Connected to the file from which data will be read</param>
        public CompressingProducer(Stream fileInputStream) {
            _lock = ProducerConsumer<T>.getLock();
            _queue = ProducerConsumer<T>.getQueue();

            _producerThread = new Thread(ProduceData);
            _producerThread.Start(fileInputStream);
        }

        /// Takes a file input stream parameter from which data will be read and put into a queue for a consumer.
        /// The parameter of this method must be object because it will be passed as a delegate to a new thread.
        public void ProduceData(object fileInputStream)
        {
            if (GZipTest.GetActionType() == ActionType.Compress) {  

                byte[] block = new byte[Settings.blockSize];
                int bytesRead;

                while ((bytesRead = ((Stream)fileInputStream).Read(block, 0, Settings.blockSize)) > 0)     
                {                    
                    if (bytesRead < block.Length)
                    {
                        byte[] block2 = new byte[bytesRead];
                        Array.Copy(block, block2, bytesRead);
                        block = block2;
                    }

                    EnqueueObject(block);   // put the data block into the queue
                    block = new byte[Settings.blockSize];
                }
        }

        private void EnqueueObject(T data) //byte[] block  or CompressedData   
        {
            lock (_lock)
            {
                while (_queue.Count >= Settings.maxQueueSize)
                {
                    Monitor.Wait(_lock);     // suspends the whole main thread of the application
                }

                _queue.Enqueue(data);

                if (_queue.Count == 1)
                {
                    // wake up any blocked dequeue, i.e. the consumer thread
                    Monitor.PulseAll(_lock);
                }
            }
        }
    }
}

我了解到您需要进一步说明该程序的工作原理。它应该用于压缩和解压缩。首先，它按块（字节数组）读取文件，然后压缩块，将它们放入我自己的类 CompressedData 的对象中，并将它们序列化为一个文件。在解压过程中，对象被反序列化，压缩后的字节数组被解压到一个新文件中。它使用生产者-消费者模式，因此有一个“生产者”将元素放入队列中，队列本身和一个“消费者”获取元素并处理所需的操作（压缩/解压缩）。我想使用我的类 CompressingProducer 作为操作、压缩和解压缩的“生产者”，这意味着它在压缩过程中将字节数组排入队列，在解压缩过程中将我的类 CompressedData 的对象排入队列。这就是我尝试使用泛型的原因。

Answer 1

这个解决方案帮助了我：

return (T)Convert.ChangeType(MyVariable, typeof(T)); 

Answer 2

在泛型类中不能将T指定为真正的类，只需将函数ProduceData带出类即可

Answer 3

课内 T 是泛型类型，它不代表任何类型或可以接受任何类型值的类型，它代表由参数确定的特定类型。

---

声明CompressingProducer的变量时需要传递类型参数，

CompressingProducer<byte[]> producer = new CompressingProducer<byte[]>();

T = 字节[]。在这种情况下，T 与类型 byte[] 匹配，但我们讨论的是泛型类型，它可以是任何类型，而不仅仅是 byte []。

考虑现在声明下面的 T 是字符串

CompressingProducer<string> producer = new CompressingProducer<string>();

T = 字符串 但是CompressingProducer.EnqueueObject方法里面需要T参数，参数不等于byte[]，等于string。

泛型有助于处理任何类型，但类型取决于声明变量时作为参数传递的类型。 问题是将类型 T 视为 CompressingProducer 类中的任何类型。 T 是在声明任何 CompressingProducer 变量时由参数确定的类型。 因此，您不能将任何值传递给 EnqueueObject 方法，只能传递 T 类型的值。

在创建变量时将类型作为参数传递时，始终将 T 视为虚拟/虚构/虚构类型，它是真实类型。

---

如果您需要处理队列中的任何类型，请在类型参数中使用 object 类，在 C# 中，除了 object 之外的任何类都继承自 object。

class CompressingProducer
    {

        Queue<Object> _queue;

        public void ProduceData(object fileInputStream)
        {
            byte[] block = new byte[Settings.blockSize];
            int bytesRead;

            while ((bytesRead = ((Stream)fileInputStream).Read(block, 0, Settings.blockSize)) > 0)
            {
                EnqueueObject(block);//Needs object of T type.
                block = new byte[Settings.blockSize];
            }
        }

        private void EnqueueObject(Object data)
        {
            _queue.Enqueue(data);
        }
    }

---

我的最终解决方案是修改ProduceData方法，添加另一个Func类型的参数，这个参数是一个委托，将byte[]转换为作为参数传递的类型。

两个例子使用：
T = 字符串
T = 人（示例类型）

   class CompressingProducer<T>
    {

        Queue<T> _queue;

        public void ProduceData(Stream fileInputStream, Func<byte[], T> convert)
        {
            byte[] block = new byte[Settings.blockSize];
            int bytesRead;

            while ((bytesRead = ((Stream)fileInputStream).Read(block, 0, Settings.blockSize)) > 0)
            {
                EnqueueObject(convert(block));//Using convert function, from byte[] ==> to T 
                block = new byte[Settings.blockSize];
            }
        }

        private void EnqueueObject(T data)
        {
            _queue.Enqueue(data);
        }
    }


    class Program
    {
        public static string ConvertData(byte[] data)
        {
            return Encoding.UTF8.GetString(data);
        }

        class Person
        {
            public long Id { get; set; }
            public String Name { get; set; }

            public byte[] ToBytes()
            {
                //this is aproach example, Needs more improvements
                return BitConverter.GetBytes(Id).Concat(Encoding.UTF8.GetBytes(Name).Take(Settings.blockSize - 8/* long type size of Id */)).ToArray(); //byte[] of blockSize size
            }

            public static Person ToPerson(byte[] bytes)
            {
                return new Person
                {
                    Id = BitConverter.ToInt64(bytes.Take(8).ToArray()),
                    Name = Encoding.UTF8.GetString(bytes.Skip(8).ToArray())
                };
            }
        }
        static void Main(string[] args)
        {
            //EXAMPLE 1
            CompressingProducer<string> producer = new CompressingProducer<string>();
            using (Stream filestream = File.OpenRead("path to file"))
            {
                //ProduceData(Stream fileInputStream, Func<byte[], string> convert), T now is string type.
                producer.ProduceData(filestream, data => Encoding.UTF8.GetString(data));//Using lambda expression. 
                producer.ProduceData(filestream, ConvertData);//Using delegate. //Same result as lambda.
            }

            //EXAMPLE 2
            CompressingProducer<Person> personProducer = new CompressingProducer<Person>();
            using (Stream filestream = File.OpenRead("path to file containing Person Blocks"))
            {
                //ProduceData(Stream fileInputStream, Func<byte[], Person> convert), T now is Person type.
                personProducer.ProduceData(filestream, data => Person.ToPerson(data));//Using lambda expression. 
            }

            Console.ReadLine();
        }
    }

Answer 4

ProduceData() 与byte[] 紧耦合，所以Queue<T> 中的元素类型应该相同：

class CompressingProducer
{
    private readonly Queue<byte[]> _queue;

    public void ProduceData(object fileInputStream)
    {
        byte[] block = new byte[Settings.blockSize];

        while (((Stream)fileInputStream).Read(block, 0, Settings.blockSize) > 0)
        {
            EnqueueObject(block);
            block = new byte[Settings.blockSize];
        }
    }

    private void EnqueueObject(byte[] block)
    {
        _queue.Enqueue(block);
    }
}

更新

为了保持通用性，您应该这样做：

public abstract class CompressingProducer<T>
{
    public Queue<T> Queue { get; set; }

    public abstract void ProduceData(object fileInputStream);

    protected void EnqueueObject(T element)
    {
        Queue.Enqueue(element);
    }
}

public class CompressingProducerByByteArray : CompressingProducer<byte[]>
{
    public override void ProduceData(object fileInputStream)
    {
        byte[] block = new byte[Settings.blockSize];

        while (((Stream)fileInputStream).Read(block, 0, Settings.blockSize) > 0)
        {
            EnqueueObject(block);
            block = new byte[Settings.blockSize];
        }
    }
}