C# Generics - cannot convert 'byte[]' to 'T'

Question

I need your help with using generic class and methods in C#. When I call EnqueObject method in ProduceData, on the line with EnqueueObject(block), an error occurs: cannot convert 'byte[]' to 'T'. I would appreciate any advice.

(I've simplified my code because I believe my problem is something really basic).

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);
    }
}

---

UPDATE

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);
                }
            }
        }
    }
}

I've understood you need a further explanation of how the program should work. It should be used for compression and decompression. At first, it reads a file by blocks (byte arrays), then compresses the blocks, puts them in objects of my own class CompressedData and serializes them into one file. During the decompression the objects are deserialized and the zipped byte arrays are decompressed into a new file. It uses producer-consumer pattern, so there is a "producer" putting elements in a queue, the queue itself and a "consumer" taking elemens and processes the required operation (compression/decompression). I want to use my class CompressingProducer as "producer" of both operations, compression and decompression, it means it enqueues byte arrays during compression, and objects of my class CompressedData during decompression. It's why I'm trying to use generics.

Answer 1

this solution helped me:

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

Answer 2

You can't specify T as a real class in the generic class, just bring function ProduceData out of class

Answer 3

Inside of class T is a generic type, it not represents any type or a type which can be accept any type of value, it represents a especific type determined by parameter.

---

When you declare a variable of CompressingProducer you need to pass the type parameter,

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

T = byte[]. In this case T matches with the type byte[] but we are talking about generic types which can be any type not only byte [].

Consider declaring following T now is string

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

T = string but inside the CompressingProducer.EnqueueObject method needs T parameter, parameter is not equals to byte[], is equal to string.

Generics helps to handle any type, but type depends on type passed as parameter when declare variable. The problem is to treat type T as any type inside the CompressingProducer class. T is a type determined by parameter when declaring any CompressingProducer variable. For this reason, you cannot pass any value to the EnqueueObject method, only values of type T.

Consider allways T as a virtual/fiction/imaginary type which is a real type when pass type as parameter when create a variable.

---

If you need to handle any type in the Queue use the object class in type parameter, in C# any class excepts object inherits from 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);
        }
    }

---

My final solution is modify ProduceData method, add another parameter of type Func, this parameter is a delegate to convert from byte[] to type passed as parameter.

Two examples using:
T = string
T = Person (Example type)

   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() is tightly coupled with byte[], so the type of elements in the Queue<T> should have the same:

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);
    }
}

Update

To keet the generic you should do something like this:

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];
        }
    }
}