MagicDictionary

最新推荐文章于 2022-07-16 01:14:26 发布

原创最新推荐文章于 2022-07-16 01:14:26 发布 · 297 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#dictionary #string #thread #object #class #null

本文全面概述了信息技术领域的多个细分技术领域，包括前端开发、后端开发、移动开发、游戏开发等，提供了各领域的核心概念、关键技术和应用实例，旨在为读者提供一个全面的技术视角。

//Gadgets

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace sevenFourMagicDictionary
{
[PrintModifierAttribute('g')]
public class Gadgets
{
string mem;

public string Mem
{
get { return mem; }
set { mem = value; }
}

public Gadgets(string m)
{
mem = m;
}

public override string ToString()
{
return mem;
}
}
}

//Widgets

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

namespace sevenFourMagicDictionary
{
[PrintModifierAttribute('w')]
public class Widgets
{
string mem;

public string Mem
{
get { return mem; }
set { mem = value; }
}

public Widgets(string m)
{
mem = m;
}

public override string ToString()
{
return mem;
}
}
}

//MagicDictionary

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace sevenFourMagicDictionary
{
class MagicDictionaryGenericDelegate<K, V>
where V : class
{
Dictionary<K, V> dictionary = new Dictionary<K,V>();

public delegate void DoSomething(V value);

public event EventHandler<MagicDictionaryEventArgs<K, V>> addRemoveEventHandler;

/* object o = new Object();
public event EventHandler<MagicDictionaryEventArgs<K, V>> addRemoveEventHandler
{
add
{
lock (o)
{
addRemoveEventHandler += value;
}
}

remove
{
lock (o)
{
addRemoveEventHandler -= value;
}
}

}
*/

public event EventHandler<PrintEventArgs<V>> printEventHandler;

public MagicDictionaryGenericDelegate()
{

}

public void Add(K key, V value)
{
lock (dictionary)
{
Console.Write("Add begin ");
if (dictionary.ContainsKey(key))
throw new MagicDictionaryException(key + " already exists in MagicDictionary");
dictionary.Add(key, value);
if (addRemoveEventHandler != null)
addRemoveEventHandler(this, new MagicDictionaryEventArgs<K, V>(key, value));
Monitor.PulseAll(dictionary);
Console.WriteLine(" Add exit ");

}
}

public void Remove(K key)
{
lock (dictionary)
{
Console.Write("Remove begin ");
while (!dictionary.ContainsKey(key))
{
// throw new MagicDictionaryException(key + " doesn't exist");
Console.WriteLine("wait for {0}", key);
Monitor.Wait(dictionary);
}
V value = dictionary[key];
dictionary.Remove(key);
if (addRemoveEventHandler != null)
addRemoveEventHandler(this, new MagicDictionaryEventArgs<K, V>(key, value));
Monitor.PulseAll(dictionary);
Console.WriteLine(" Remove exit ");
}
}

public void Set(K key, V value)
{
if (dictionary.ContainsKey(key))
dictionary[key] = value;
else
dictionary.Add(key, value);
}

public V Get(K key)
{
return dictionary[key];
}

public V this[K key]
{
get
{
return dictionary[key];
}
}

public void PrintAll(DoSomething doSth)
{
foreach (V value in dictionary.Values)
{
doSth(value);
}

}

public void PrintAll()
{
lock (dictionary)
{
Console.WriteLine("PrintAll begin");
foreach (KeyValuePair<K, V> entry in dictionary)
{
Console.Write("{0} = ", entry.Key);
if (printEventHandler != null)
printEventHandler(this, new PrintEventArgs<V>(entry.Value));
}
Console.WriteLine("PrintAll exit");
}

}

public bool TryGetValue(K key, out V value)
{
if (dictionary.ContainsKey(key)) {
value = dictionary[key];
return true;
}
value = null;
return false;
}
}
}

//PrintEventArgs

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

namespace sevenFourMagicDictionary
{
class PrintEventArgs<V> : EventArgs
{
V value;

public V Value
{
get { return this.value; }
set { this.value = value; }
}

public PrintEventArgs(V v)
{
value = v;
}
}
}

//PrintMOdifierAttribute

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

namespace sevenFourMagicDictionary
{
class PrintModifierAttribute : Attribute
{
char ch;

public char Ch
{
get { return ch; }
}

public PrintModifierAttribute(char c)
{
ch = c;
}

}
}

//MagicDictionaryEventArgs

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

namespace sevenFourMagicDictionary
{
public class MagicDictionaryEventArgs<K, V> : EventArgs
where V : class
{
K key;
V value;

public V Value
{
get { return this.value; }
}

public K Key
{
get { return key; }
}

public MagicDictionaryEventArgs(K k, V v)
{
key = k;
value = v;
}

}
}

//Program

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Threading;

namespace sevenFourMagicDictionary
{
class Program
{
static void Main(string[] args)
{
// tesTGeneric();
// testGenericDelegate();

//testEvent();

//testWidgetsAndGadgets();
// testConstructGeneric();
//
// testNonGenericSql();

testThread();
}

static void testNonGeneric()
{
MagicDictionary d = new MagicDictionary();

try
{
d.Add("one", "ONE");
d.Add("two", "TWO");
d.Add("three", "THREE");

d.Add("one", "One");
d.Add("two", "TWO");
}
catch (MagicDictionaryException e)
{
Console.Error.WriteLine(e);
}
d.PrintAll();
Console.WriteLine();

try
{
d.Remove("one");
d.Remove("four");
}
catch (MagicDictionaryException e)
{
Console.Error.WriteLine(e);
}
d.PrintAll();
Console.WriteLine();

d.Set("four", "FOUR");
d.Set("two", "2");
d.PrintAll();
Console.WriteLine();

testTryGetValue(d, "one");
testTryGetValue(d, "two");

Console.WriteLine();
Console.WriteLine(d.Get("two"));
Console.WriteLine(d["two"]);
}

static void testTryGetValue(MagicDictionary d, string key)
{
string value = null;
if (d.TryGetValue(key, out value))
Console.WriteLine("{0} = {1}", key, value);
else
Console.WriteLine("{0} dosen't exist", key);
}

static void tesTGeneric()
{
MagicDictionaryGeneric<string, string> d = new MagicDictionaryGeneric<string ,string>();

try
{
d.Add("one", "ONE");
d.Add("two", "TWO");
d.Add("three", "THREE");

d.Add("one", "One");
d.Add("two", "TWO");
}
catch (MagicDictionaryException e)
{
Console.Error.WriteLine(e);
}
d.PrintAll();
Console.WriteLine();

try
{
d.Remove("one");
d.Remove("four");
}
catch (MagicDictionaryException e)
{
Console.Error.WriteLine(e);
}
d.PrintAll();
Console.WriteLine();

d.Set("four", "FOUR");
d.Set("two", "2");
d.PrintAll();
Console.WriteLine();

testTryGetValueGeneric(d, "one");
testTryGetValueGeneric(d, "two");

Console.WriteLine();
Console.WriteLine(d.Get("two"));
Console.WriteLine(d["two"]);
}

static void testTryGetValueGeneric<K, V>(MagicDictionaryGeneric<K, V> d, K key)
where V : class
{
V value = null;
if (d.TryGetValue(key, out value))
Console.WriteLine("{0} = {1}", key, value);
else
Console.WriteLine("{0} dosen't exist", key);
}

static void Longest(string str)
{
if (str.Length > maxStr.Length)
maxStr = str;
}

static string maxStr = "";
//add event handler
static void AddRemoveHandler<K, V>(object sender, MagicDictionaryEventArgs<K, V> e)
where V : class
{
MagicDictionaryGenericDelegate<K, V> d = sender as MagicDictionaryGenericDelegate<K, V>;
// Console.WriteLine(d);
Console.Write("{0} = {1}", e.Key, e.Value);
}
static void testGenericDelegate()
{
MagicDictionaryGenericDelegate<string, string> d =
new MagicDictionaryGenericDelegate<string, string>();

try
{
d.Add("one", "ONE");
d.Add("two", "TWO");
d.Add("three", "THREE");
d.Add("four", "FOUR");

d.Add("one", "One");
d.Add("two", "TWO");
}
catch (MagicDictionaryException e)
{
Console.Error.WriteLine(e);
}
d.PrintAll(Console.WriteLine);
Console.WriteLine();

/*
* d.PrintAll(Longest);
* the follwoing one is using anonymous delegate
*/
// d.PrintAll(Longest);
d.PrintAll(delegate(string str)
{
if (str.Length > maxStr.Length)
maxStr = str;
});
Console.WriteLine(maxStr);

}

static void testEvent()
{
MagicDictionaryGenericDelegate<string, string> d =
new MagicDictionaryGenericDelegate<string, string>();
//test event
d.addRemoveEventHandler += AddRemoveHandler;
d.Add("five", "FIVE");
Console.WriteLine();
d.Remove("five");
}

//the following is using EventHandler
static void printEventHandler<V>(object sender, PrintEventArgs<V> e)
where V : class
{
Type type = e.Value.GetType();

if(type == Type.GetType("sevenFourMagicDictionary.Widgets")){
// Widgets w = sender as Widgets;
Console.WriteLine("*s {0}", e.Value);
}
else if (type == Type.GetType("sevenFourMagicDictionary.Gadgets"))
{
Console.WriteLine("#s {0}", e.Value);
}
else
Console.WriteLine(e.Value);

}

//using Attribute
static void printEventHandlerByAttribute<V>(object sender, PrintEventArgs<V> e)
where V : class
{
Type type = e.Value.GetType();
if(type.IsDefined(typeof(PrintModifierAttribute), false))
{
PrintModifierAttribute[] attr = (PrintModifierAttribute[])
type.GetCustomAttributes(typeof(PrintModifierAttribute), false);
if(attr[0].Ch == 'w')
Console.Write("*s ");
else if(attr[0].Ch == 'g')
Console.Write("#s ");
}

Console.WriteLine(e.Value);

}
//ten four
static void testWidgetsAndGadgets()
{
MagicDictionaryGenericDelegate<int, Widgets> d1 =
new MagicDictionaryGenericDelegate<int, Widgets>();
d1.Add(1, new Widgets("widget1"));
d1.Add(2, new Widgets("widget2"));
// d1.printEventHandler += printEventHandler;
d1.printEventHandler += printEventHandlerByAttribute;
d1.PrintAll();

MagicDictionaryGenericDelegate<int, Gadgets> d2 =
new MagicDictionaryGenericDelegate<int, Gadgets>();
d2.Add(1, new Gadgets("gadget1"));
d2.Add(2, new Gadgets("gadget2"));
// d2.printEventHandler += printEventHandler;
d2.printEventHandler += printEventHandlerByAttribute;
d2.PrintAll();

MagicDictionaryGenericDelegate<int, String> d3 =
new MagicDictionaryGenericDelegate<int, String>();
d3.Add(1, "str1");
d3.Add(2, "str2");
// d3.printEventHandler += printEventHandler;
d3.printEventHandler += printEventHandlerByAttribute;
d3.PrintAll();
}

//elevent one
static void testConstructGeneric()
{
Type open = typeof(MagicDictionaryGenericDelegate<,>);
Type closed = open.MakeGenericType(
typeof(Int32),
typeof(String)
);

object obj1 = Activator.CreateInstance(closed);
object ojb2 = closed.InvokeMember(
null,
BindingFlags.CreateInstance,
null,
null,
new Object[] { });

MethodInfo add = closed.GetMethod("Add");
add.Invoke(obj1, new Object[]{1, "str1"});

MethodInfo add2 = open.GetMethod("Add");
add.Invoke(obj1, new Object[]{2, "str2"});

MagicDictionaryGenericDelegate<int, string> d = obj1 as MagicDictionaryGenericDelegate<int, string>;
d.printEventHandler += printEventHandlerByAttribute;
d.PrintAll();

Console.WriteLine();
///////
Type closed2 = open.MakeGenericType(typeof(Int32), Type.GetType("System.String"));
Object obj3 = Activator.CreateInstance(closed2);
add.Invoke(obj3, new Object[] { 3, "str3" });
add.Invoke(obj3, new Object[] { 4, "str4" });
MagicDictionaryGenericDelegate<int, string> d3 = obj3 as MagicDictionaryGenericDelegate<int, string>;
d3.printEventHandler += printEventHandlerByAttribute;
d3.PrintAll();

}

static void testNonGenericSql()
{
MagicDictionary d = new MagicDictionary();
d.Add("one", "ONE");
d.Add("two", "TWO");
d.Add("three", "THREE");
d.PrintAll();
Console.WriteLine();

// d.sort1();
// d.sort2();
d.sort3();

}

static MagicDictionaryGenericDelegate<int, string> dictionary =
new MagicDictionaryGenericDelegate<int, string>();
static void testThread()
{
dictionary.addRemoveEventHandler += AddRemoveHandler;
dictionary.printEventHandler += printEventHandler;

// Thread addThread = new Thread(Add);
// Thread removeThread = new Thread(Remove);
// Thread printThread = new Thread(Print);
Thread addThread = new Thread(
() =>
{
for (int i = 0; i < 10; i++)
{
dictionary.Add(addCnt, "value" + addCnt);
Thread.Sleep(500);
addCnt++;
}
}
);
Thread removeThread = new Thread(
() =>
{
for (int i = 0; i < 10; i++)
{
dictionary.Remove(removeCnt);
Thread.Sleep(300);
removeCnt++;
}
}
);
Thread printThread = new Thread(
() =>
{
dictionary.PrintAll();
Thread.Sleep(100);
}
);

addThread.Start();
printThread.Start();
removeThread.Start();

Console.WriteLine("Main exit");
}

static int addCnt = 0;
static void Add()
{
for (int i = 0; i < 10; i++)
{
dictionary.Add(addCnt, "value" + addCnt);
Thread.Sleep(500);
addCnt++;
}
}

static int removeCnt = 0;
static void Remove()
{
for (int i = 0; i < 10; i++)
{
dictionary.Remove(removeCnt);
Thread.Sleep(300);
removeCnt++;
}
}

static void Print()
{
for (int i = 0; i < 50; i++)
{
dictionary.PrintAll();
Thread.Sleep(100);
}
}
}
}