Csharp/C Sharp/Generics/Generic Interface

Demonstrate a generic interface

using System;
public interface ISequence<T> {
  T getNext(); 
  void reset(); 
  void setStart(T v);
}
class ByTwos<T> : ISequence<T> {
  T start;
  T val;
  public delegate T IncByTwo(T v);
  IncByTwo incr;
  public ByTwos(IncByTwo incrMeth) {
    start = default(T);
    val = default(T);
    incr = incrMeth;
  }
  public T getNext() {
    val = incr(val);
    return val;
  }
  public void reset() {
    val = start;
  }
  public void setStart(T v) {
    start = v;
    val = start;
  }
}
class GenIntfDemo {
  static int intPlusTwo(int v) {
    return v + 2;
  }
  static double doublePlusTwo(double v) {
    return v + 2.0;
  }
  public static void Main() {
    ByTwos<int> intBT = new ByTwos<int>(intPlusTwo);
    for(int i=0; i < 5; i++)
      Console.Write(intBT.getNext() + "  ");
    Console.WriteLine();
    ByTwos<double> dblBT = new ByTwos<double>(doublePlusTwo);
    dblBT.setStart(11.4);
    for(int i=0; i < 5; i++)
      Console.Write(dblBT.getNext() + "  ");
  }
}

Generic Interface Demo

 
using System;
using System.Collections.Generic;
using System.Text;
class Program {
    static void Main(string[] args) {
        Console.WriteLine("Generic Interfaces");
        BasicMath m = new BasicMath();
        Console.WriteLine("1 + 1 = {0}", m.Add(1, 1));
        Console.ReadLine();
    }
}
public interface IBinaryOperations<T> {
    T Add(T arg1, T arg2);
    T Subtract(T arg1, T arg2);
    T Multiply(T arg1, T arg2);
    T Divide(T arg1, T arg2);
}
public class BasicMath : IBinaryOperations<int> {
    public int Add(int arg1, int arg2) { return arg1 + arg2; }
    public int Subtract(int arg1, int arg2) { return arg1 - arg2; }
    public int Multiply(int arg1, int arg2) { return arg1 * arg2; }
    public int Divide(int arg1, int arg2) { return arg1 / arg2; }

}

Generic parameter interface

 
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
public interface IPresentation {
    string Title {
        get;
    }
    string Content {
        get;
    }
}
public class Presentation : IPresentation {
    private string title;
    public string Title {
        get {
            return title;
        }
    }
    private string content;
    public string Content {
        get {
            return content;
        }
    }

    public Presentation(string title, string content) {
        this.title = title;
        this.content = content;
    }
}
public class ProcessPresentations<TPresentation, TPresentationManager>
    where TPresentation : IPresentation
    where TPresentationManager : IPresentationManager<TPresentation> {
    public static void Start(TPresentationManager dm) {
        new Thread(new ProcessPresentations<TPresentation, TPresentationManager>(dm).Run).Start();
    }
    protected ProcessPresentations(TPresentationManager dm) {
        documentManager = dm;
    }
    private TPresentationManager documentManager;
    protected void Run() {
        while (true) {
            if (documentManager.IsPresentationAvailable) {
                TPresentation doc = documentManager.GetPresentation();
                Console.WriteLine("Processing document {0}", doc.Title);
            }
            Thread.Sleep(20);
        }
    }
}
public interface IPresentationManager<T> {
    void AddPresentation(T doc);
    T GetPresentation();
    bool IsPresentationAvailable {
        get;
    }
}
public class PresentationManager<T> : IPresentationManager<T> {
    private Queue<T> documentQueue = new Queue<T>();
    public void AddPresentation(T doc) {
        lock (this) {
            documentQueue.Enqueue(doc);
        }
    }
    public T GetPresentation() {
        T doc;
        lock (this) {
            doc = documentQueue.Dequeue();
        }
        return doc;
    }
    public bool IsPresentationAvailable {
        get {
            return (documentQueue.Count > 0) ? true : false;
        }
    }
}
class Program {
    static void Main(string[] args) {
        PresentationManager<Presentation> dm = new PresentationManager<Presentation>();
        ProcessPresentations<Presentation, PresentationManager<Presentation>>.Start(dm);
        for (int i = 0; i < 1000; i++) {
            Presentation d1 = new Presentation("title" + i.ToString(), "content");
            dm.AddPresentation(d1);
            Console.WriteLine("added document {0}", d1.Title);
            Thread.Sleep(10);
        }
    }
}