ASP.NET & Csharp (C#)

ASP.NET & Csharp (C#) , Here you can find my posts about .NET c# .

A generic class with two generic parameters

Posted on by coder 
   
 

using System;
using System.Collections.Generic;
using System.Text;



class MyCache<K, V> {
    private static Dictionary<K, V> _objectCache;

    public MyCache() {
        MyCache<K, V>._objectCache = new Dictionary<K, V>();
    }

    private V FindValueInDB(K key) {
        return default(V);
    }

    public V LookupValue(K key) {
        V retVal;
        if (_objectCache.ContainsKey(key) == true) {
            _objectCache.TryGetValue(key, out retVal);
        } else {
            retVal = FindValueInDB(key);
        }
        return retVal;
    }
}
class MyApp {
    public static void main(String[] args) {
        MyCache<string, string> cache1 = new MyCache<string, string>();
        string val1 = cache1.LookupValue("key1");

        MyCache<string, int> cache2 = new MyCache<string, int>();
        int val2 = cache2.LookupValue("key1");
    }
}

Walk through a tree recursively

Posted on by coder 
   
 

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<int> tree1 = new Tree<int>(10);
        tree1.Insert(5);
        tree1.Insert(1);
        tree1.Insert(15);
        tree1.Insert(-2);
        tree1.Insert(115);
        tree1.Insert(10);
        tree1.Insert(114);
        tree1.Insert(-18);
        tree1.Insert(1110);
        tree1.Insert(81);
        tree1.Insert(18);
        tree1.WalkTree();

        Tree<string> tree2 = new Tree<string>("Hello");
        tree2.Insert("A");
        tree2.Insert("B");
        tree2.Insert("C");
        tree2.Insert("D");
        tree2.Insert("E");
        tree2.Insert("F");
        tree2.Insert("G");
        tree2.Insert("H");
        tree2.Insert("I");
        tree2.Insert("J");
        tree2.Insert("K");
        tree2.WalkTree();
    }
}

Generic Binary Tree

Posted on by coder 
   
 

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>(&#039;M&#039;);
        InsertIntoTree<char>(charTree, &#039;X&#039;, &#039;A&#039;, &#039;M&#039;, &#039;Z&#039;, &#039;Z&#039;, &#039;N&#039;);
        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);
        }
    }
}

Generic TreeNode

Posted on by coder 
   
 




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

Posted on by coder 


   

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

Posted on by coder 
   
 



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

Posted on by coder

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(dm).Run)).Start();
}

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 : IDocumentManager {
private readonly Queue documentQueue = new 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 dm = new DocumentManager();
ProcessDocuments>.Start(dm);
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]