using System; using System.Collections.Generic; using System.Linq; using System.Text; using System; using System.Collections.Generic; using System.Linq; using System.Text; public class Tree<TItem> where TItem : IComparable<TItem> { public Tree(TItem nodeValue) { this.NodeData = nodeValue; this.LeftTree = null; this.RightTree = null; } public void Insert(TItem newItem) { TItem currentNodeValue = this.NodeData; if (currentNodeValue.CompareTo(newItem) > 0) { if (this.LeftTree == null) { this.LeftTree = new Tree<TItem>(newItem); } else { this.LeftTree.Insert(newItem); } } else { if (this.RightTree == null) { this.RightTree = new Tree<TItem>(newItem); } else { this.RightTree.Insert(newItem); } } } public void WalkTree() { if (this.LeftTree != null) { this.LeftTree.WalkTree(); } Console.WriteLine(this.NodeData.ToString()); if (this.RightTree != null) { this.RightTree.WalkTree(); } } public TItem NodeData { get; set; } public Tree<TItem> LeftTree { get; set; } public Tree<TItem> RightTree { get; set; } } class Program { static void Main(string[] args) { Tree<char> charTree = new Tree<char>('M'); InsertIntoTree<char>(charTree, 'X', 'A', 'M', 'Z', 'Z', 'N'); charTree.WalkTree(); } static void InsertIntoTree<T>(Tree<T> tree, params T[] data) where T : IComparable<T> { if (data.Length == 0) throw new ArgumentException("Must provide at least one data value"); foreach (T datum in data) { tree.Insert(datum); } } }
Generics
Generic TreeNode
using System; using System.Collections.Generic; using System.Text; using System.Collections; public class Employee { private int _id = 0; private string _name = null; public Employee(int id, string name) { this._id = id; this._name = name; } public int Id { get { return this._id; } } public string Name { get { return this._name; } } public override string ToString() { return this._name; } } public class TreeNode<T> { private T _nodeData; private ArrayList _childNodes; public TreeNode(T nodeData) { this._nodeData = nodeData; this._childNodes = new ArrayList(); } public T Data { get { return this._nodeData; } } public TreeNode<T>[] Children { get { return (TreeNode<T>[])this._childNodes.ToArray(typeof(TreeNode<T>)); } } public TreeNode<T> this[int index] { get { return (TreeNode<T>)this._childNodes[index]; } } public TreeNode<T> AddChild(T nodeData) { TreeNode<T> newNode = new TreeNode<T>(nodeData); this._childNodes.Add(newNode); return newNode; } public override string ToString() { return this._nodeData.ToString(); } } class Program { static void Main(string[] args) { TreeNode<Employee> rootNode = new TreeNode<Employee>(new Employee(111, "H")); TreeNode<Employee> child1 = rootNode.AddChild(new Employee(222, "B")); rootNode.AddChild(new Employee(333, "T")); child1.AddChild(new Employee(444, "B")); child1.AddChild(new Employee(555, "M")); } }
Demonstrate a generic struct
using System; struct XY<T> { T x; T y; public XY(T a, T b) { x = a; y = b; } public T X { get { return x; } set { x = value; } } public T Y { get { return y; } set { y = value; } } } class StructTest { public static void Main() { XY<int> xy = new XY<int>(1, 2); XY<double> xy2 = new XY<double>(8.0, 9.0); Console.WriteLine(xy.X + ", " + xy.Y); Console.WriteLine(xy2.X + ", " + xy2.Y); } }
Custom Generic ISerializable
using System; using System.Collections.Generic; using System.Text; using System.IO; using System.Runtime.Serialization; using System.Runtime.Serialization.Formatters.Binary; [Serializable] public class CustomClass1<T> : ISerializable { private int _intData; private string _stringData; private T _genericData; public CustomClass1() { } private CustomClass1(SerializationInfo serInfo, StreamingContext context) { _intData = (int)serInfo.GetValue("_intData", typeof(int)); _stringData = (string)serInfo.GetValue("_stringData", typeof(string)); _genericData = (T)serInfo.GetValue("_genericData", typeof(T)); } public CustomClass1(int intData, string stringData, T genericType) { this._intData = intData; this._stringData = stringData; this._genericData = genericType; } public void GetObjectData(SerializationInfo serInfo, StreamingContext context) { serInfo.AddValue("_intData", _intData); serInfo.AddValue("_stringData", _stringData); serInfo.AddValue("_genericData", _genericData, _genericData.GetType()); } public int IntVal { get { return this._intData; } } public string StrVal { get { return this._stringData; } } public T GenericVal { get { return this._genericData; } } } public class MainClass{ public static void Main(){ CustomClass1<Double> doubleClass; doubleClass = new CustomClass1<Double>(111, "Value1", 939.99); MemoryStream stream = new MemoryStream(); BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(stream, doubleClass); stream.Seek(0, SeekOrigin.Begin); CustomClass1<Double> newClass = (CustomClass1<Double>)formatter.Deserialize(stream); Console.Out.WriteLine("Int Data Member : {0}", newClass.IntVal); Console.Out.WriteLine("String Data Member : {0}", newClass.StrVal); Console.Out.WriteLine("Generic Data Member : {0}", newClass.GenericVal); } }
Two Generic parameters
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
public interface IDocument {
string Title {
get;
}
string Content {
get;
}
}
public class Document : IDocument {
private string title;
public string Title {
get {
return title;
}
}
private string content;
public string Content {
get {
return content;
}
}
public Document(string title, string content) {
this.title = title;
this.content = content;
}
}
public class ProcessDocuments
where T : IDocument
where U : IDocumentManager
public static void Start(U dm) {
new Thread(new ThreadStart(new ProcessDocuments
}
protected ProcessDocuments(U dm) {
documentManager = dm;
}
private U documentManager;
protected void Run() {
while (true) {
if (documentManager.IsDocumentAvailable) {
T doc = documentManager.GetDocument();
Console.WriteLine(“Processing document {0}”, doc.Title);
}
Thread.Sleep(new Random().Next(20));
}
}
}
public interface IDocumentManager
void AddDocument(T doc);
T GetDocument();
bool IsDocumentAvailable {
get;
}
}
public class DocumentManager
private readonly Queue
public void AddDocument(T doc) {
lock (this) {
documentQueue.Enqueue(doc);
}
}
public T GetDocument() {
T doc = default(T);
lock (this) {
doc = documentQueue.Dequeue();
}
return doc;
}
public bool IsDocumentAvailable {
get {
return (documentQueue.Count > 0) ? true : false;
}
}
}
class Program {
static void Main(string[] args) {
DocumentManager
ProcessDocuments
for (int i = 0; i < 1000; i++) {
Document doc = new Document("Doc " + i.ToString(), "content");
dm.AddDocument(doc);
Console.WriteLine("added document {0}", doc.Title);
Thread.Sleep(new Random().Next(20));
}
}
}
[/csharp]
Serialize and Deserialize generic objects
using System; using System.Runtime.Serialization; using System.Runtime.Serialization.Formatters.Binary; using System.IO; public class Starter { public static void Main(string[] args) { BinaryFormatter binary = new BinaryFormatter(); FileStream file = new FileStream("data.bin", FileMode.OpenOrCreate); MyClass<int> obj = new MyClass<int>(5); binary.Serialize(file, obj); MyClass<int> obj1 = (MyClass<int>) binary.Deserialize(file); Console.WriteLine(obj1.GetValue()); } } [Serializable] public class MyClass<T> { public MyClass(T init) { fielda = init; } public void GetObjectData(SerializationInfo info,StreamingContext ctx) { info.AddValue("fielda", fielda, typeof(T)); } private MyClass(SerializationInfo info,StreamingContext ctx) { fielda = (T)info.GetValue("fielda", typeof(T)); } public void SetValue(T data) { fielda = data; } public T GetValue() { return fielda; } private T fielda = default(T); }
Generic methods can overload nongeneric methods
using System; public class Starter{ public static void Main(){ MethodA(5); MethodA(5.0); } public static void MethodA<T>(T arg) { Console.WriteLine("ZClass.MethodA(T arg)"); } public static void MethodA(int arg) { Console.WriteLine("ZClass.MethodA(int arg)"); } public static void MethodA() { Console.WriteLine("ZClass.MethodA()"); } }