抽象类和不可为null的值类型

我正在尝试编译代码（生产者/消费者模式的迭代器更有趣)由大师"Joe Duffy"提出，用于类生产者/消费者，但此错误正在发生：

（我使用的是visualstudio2010和net4.0.3）

Program.cs（37,34）：error CS0453:类型"T"必须是不可为null的值类型，才能将其用作泛型类型或方法"System.nullable"中的参数"T"Program.cs（11,40）：（相关位置）Program.cs（37,61）：error CS0453:类型"T"必须是不可为null的值类型，才能将其用作泛型类型或方法"System.nullable"中的参数"T"Program.cs（11,40）：（相关位置）Program.cs（44,53）：error CS0453:类型"T"必须是不可为null的值类型，才能将其用作泛型类型或方法"System.nullable"中的参数"T"Program.cs（11,40）：（相关位置）

对我微薄的知识来说太多了！有人能提出一个解决方案吗？

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ProducerConsumerClass
{
    class Program
    {
        public abstract class Producer<T>
        {
            public Producer()
            {
                worker = new Thread(new ThreadStart(this.ProductionCycle));
            }
            private Queue<T> buffer = new Queue<T>();
            public Thread worker;
            private bool done;
            public bool Done
            {
                get
                {
                    return done;
                }
            }
            public IEnumerable<T> ConsumerChannel
            {
                get
                {
                    if (done)
                        throw new InvalidOperationException("Production is not currently active");
                    while (!done)
                    {
                        Nullable<T> consumed = new Nullable<T>();
                        //BUG: compiler crashes when using lock(...) construct within iterator
                        Monitor.Enter(buffer);
                        if (buffer.Count == 0)
                            Monitor.Wait(buffer);
                        if (buffer.Count > 0)
                            consumed = new Nullable<T>(buffer.Dequeue());
                        Monitor.Exit(buffer);
                        if (consumed.HasValue)
                            yield return consumed.Value;
                    }
                    yield break;
                }
            }
            public void BeginProduction()
            {
                done = false;
                worker.Start();
            }
            public void EndProduction()
            {
                done = true;
                lock (buffer)
                {
                    Monitor.PulseAll(buffer);
                }
            }
            private void ProductionCycle()
            {
                while (!done)
                {
                    T t = ProduceNext();
                    lock (buffer)
                    {
                        buffer.Enqueue(t);
                        Monitor.Pulse(buffer);
                    }
                }
            }
            protected abstract T ProduceNext();
        }
        public abstract class Consumer<T>
        {
            public Consumer(Producer<T> producer)
            {
                this.producer = producer;
                worker = new Thread(new ThreadStart(this.ConsumerCycle));
            }
            private Producer<T> producer;
            public Thread worker;
            private bool done = false;
            public bool Done
            {
                get
                {
                    return done;
                }
            }
            public void BeginConsumption()
            {
                done = false;
                worker.Start();
            }
            public void EndConsumption()
            {
                done = true;
            }
            private void ConsumerCycle()
            {
                foreach (T t in producer.ConsumerChannel)
                {
                    Consume(t);
                    if (done)
                        break;
                }
            }
            protected abstract void Consume(T t);
        }
        class RandomNumberProducer : Producer<int>
        {
            public RandomNumberProducer()
                : base()
            {
                rand = new Random();
            }
            private Random rand;
            protected override int ProduceNext()
            {
                return rand.Next();
            }
        }
        class RandomNumberConsumer : Consumer<int>
        {
            public RandomNumberConsumer(RandomNumberProducer p)
                : base(p)
            {
            }
            private static int counter = 0;
            private int id = ++counter;
            protected override void Consume(int t)
            {
                Console.Out.WriteLine("#{0}: consumed {1}", id, t);
            }
        }
        static void Main(string[] args)
        {
            RandomNumberProducer p = new RandomNumberProducer();
            RandomNumberConsumer c1 = new RandomNumberConsumer(p);
            RandomNumberConsumer c2 = new RandomNumberConsumer(p);
            RandomNumberConsumer c3 = new RandomNumberConsumer(p);
            p.BeginProduction();
            c1.BeginConsumption();
            c2.BeginConsumption();
            c3.BeginConsumption();
            Thread.Sleep(2500);
            c3.EndConsumption();
            c2.EndConsumption();
            c1.EndConsumption();
            p.EndProduction();
        }
    }
}

public abstract class Producer<T> where T : struct
public abstract class Consumer<T> where T : struct