using sys = System;
using sysCols = System.Collections;
//------------------------------------------------------------------------------
// <autogenerated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------
using System;
using System.Collections;
public class Orders : IDictionary, ICollection, IEnumerable, ICloneable
{
protected Hashtable innerHash;
public Orders() {innerHash = new Hashtable();}
public Orders(Orders original) {innerHash = new Hashtable (original.innerHash);}
public Orders(IDictionary dictionary) {innerHash = new Hashtable (dictionary);}
public Orders(int capacity) {innerHash = new Hashtable(capacity);}
public Orders(IDictionary dictionary, float loadFactor) {
innerHash = new Hashtable(dictionary, loadFactor);
}
public Orders(IHashCodeProvider codeProvider, IComparer comparer) {
innerHash = new Hashtable (codeProvider, comparer);
}
public Orders(int capacity, int loadFactor) {
innerHash = new Hashtable(capacity, loadFactor);
}
public Orders(IDictionary dictionary, IHashCodeProvider codeProvider, IComparer comparer) {
innerHash = new Hashtable (dictionary, codeProvider, comparer);
}
public Orders(int capacity, IHashCodeProvider codeProvider, IComparer comparer) {
innerHash = new Hashtable (capacity, codeProvider, comparer);
}
public Orders(IDictionary dictionary, float loadFactor, IHashCodeProvider codeProvider, IComparer comparer) {
innerHash = new Hashtable (dictionary, loadFactor, codeProvider, comparer);
}
public Orders(int capacity, float loadFactor, IHashCodeProvider codeProvider, IComparer comparer)
{
innerHash = new Hashtable (capacity, loadFactor, codeProvider, comparer);
}
public System.Collections.IDictionaryEnumerator GetEnumerator() {
return new OrdersEnumerator(this);
}
IEnumerator IEnumerable.GetEnumerator() {return GetEnumerator();}
public void Remove(OrderNumber key) {innerHash.Remove (key);}
void IDictionary.Remove(object key) {Remove ((OrderNumber)key);}
public bool Contains(OrderNumber key) {return innerHash.Contains(key);}
bool IDictionary.Contains(object key) {return Contains((OrderNumber)key);}
public void Clear() {innerHash.Clear();}
public void Add(OrderNumber key, Order value) {innerHash.Add (key, value);}
void IDictionary.Add(object key, object value) {Add ((OrderNumber)key, (Order)value);}
public bool IsReadOnly {get {return innerHash.IsReadOnly;}}
public Order this[OrderNumber key] {
get {return (Order) innerHash[key];}
set {innerHash[key] = value;}
}
object IDictionary.this[object key] {
get {return this[(OrderNumber)key];}
set {this[(OrderNumber)key] = (Order)value;}
}
public System.Collections.ICollection Values {get {return innerHash.Values;}}
public System.Collections.ICollection Keys {get{return innerHash.Keys;}}
public bool IsFixedSize {get{return innerHash.IsFixedSize;}}
public void CopyTo(System.Array array, int index) {innerHash.CopyTo (array, index);}
public bool IsSynchronized {get {return innerHash.IsSynchronized;}}
public int Count {get{return innerHash.Count;}}
public object SyncRoot {get{return innerHash.SyncRoot;}}
public Orders Clone()
{
Orders clone = new Orders();
clone.innerHash = (Hashtable) innerHash.Clone();
return clone;
}
object ICloneable.Clone() {return Clone();}
public bool ContainsKey (OrderNumber key) {return innerHash.ContainsKey(key);}
public bool ContainsValue (Order value) {return innerHash.ContainsValue(value);}
public static Orders Synchronized(Orders nonSync) {
Orders sync = new Orders();
sync.innerHash = Hashtable.Synchronized(nonSync.innerHash);
return sync;
}
internal Hashtable InnerHash {get{return innerHash;}}
}
public class OrdersEnumerator : IDictionaryEnumerator
{
private IDictionaryEnumerator innerEnumerator;
internal OrdersEnumerator (Orders enumerable) {
innerEnumerator = enumerable.InnerHash.GetEnumerator();
}
public OrderNumber Key {get{return (OrderNumber)innerEnumerator.Key;}}
object IDictionaryEnumerator.Key {get{return Key;}}
public Order Value {get{return (Order)innerEnumerator.Value;}}
object IDictionaryEnumerator.Value {get{return Value;}}
public System.Collections.DictionaryEntry Entry {get{return innerEnumerator.Entry;}}
public void Reset() {innerEnumerator.Reset();}
public bool MoveNext() {return innerEnumerator.MoveNext();}
public object Current {get {return innerEnumerator.Current;}}
}
//
//-----------------------------------------------------------------------------------------------
// Key: Order
//-----------------------------------------------------------------------------------------------
//
public struct OrderNumber
{
private static int globalNum = 1000;
public int Year;
public int Number;
public void SetNewOrderNumber()
{
Year =sys.DateTime.Now.Year;
Number = ++globalNum;
}
public override int GetHashCode()
{
return sys.String.Format("{0}-{1}", Year, Number).GetHashCode();
}
public override string ToString()
{
return sys.String.Format("{0}-{1}", Year, Number);
}
}
//
//-----------------------------------------------------------------------------------------------
// Item: Order
//-----------------------------------------------------------------------------------------------
//
public class Order {
private OrderNumber num;
private string customer = "?";
public Order() {
num = new OrderNumber();
num.SetNewOrderNumber();
}
public Order(OrderNumber number) {num = number;}
public string Customer {
get {return customer;}
set {customer = value;}
}
public OrderNumber Number {
get {return num;}
}
public override string ToString() {
return sys.String.Format("[{0} {1}]", num, customer);
}
}
//
//-----------------------------------------------------------------------------------------------
// Main App
//-----------------------------------------------------------------------------------------------
//
class MainApp{
public static void Main(){
//
// Esercito i costruttori tipizzati
//
Orders myOrders;
{
Orders tmpOrders = new Orders();
for(int i = 0; i<10; ++i)
{
Order o = new Order();
tmpOrders.Add(o.Number, o);
}
myOrders = new Orders(tmpOrders);
}
{
Orders myTmpOrders = new Orders(myOrders);
// error CS1502: The best overloaded method match for 'Orders.Orders(Orders)' has some invalid arguments
// Scommenta la linea di codice per verificare che il costruttore tipizzato funziona
//Orders myTmpOrders2 = new Orders(new object());
}
//
// Esercito l'enumeratore tipizzato
//
foreach(sysCols.DictionaryEntry numOrdPair in myOrders)
{
OrderNumber tmpOn = (OrderNumber)numOrdPair.Key; // N.B. questo Orders non implementa un Entry tipizzato
Order tmpOrd = (Order)numOrdPair.Value;
sys.Console.WriteLine("Entry Key: {0} \t\t Value: {1}", numOrdPair.Key, numOrdPair.Value);
}
//
// Esercito i metodi tipizzati
//
{
Order tmpOrd = new Order();
myOrders[tmpOrd.Number] = tmpOrd;
// error CS0029: Cannot implicitly convert type 'object' to 'Order'
// Scommenta la linea di codice per verificare che il metodo tipizzato funziona
//myOrders[tmpOrd.Number] = new object();
}
{
Order tmpOrd = new Order();
myOrders.Add(tmpOrd.Number, tmpOrd);
}
// error CS1502: The best overloaded method match for 'Orders.Add(OrderNumber, Order)' has some invalid arguments
// Scommenta la linea di codice per verificare che il metodo tipizzato
//myOrders.Add(new object(), new object());
{
Order tmpOrd = new Order();
myOrders.Add(tmpOrd.Number, tmpOrd);
myOrders.Remove(tmpOrd.Number);
// error CS1502: The best overloaded method match for 'Orders.Remove(OrderNumber)' has some invalid arguments
// Scommenta la linea di codice per verificare che il metodo tipizzato funziona
//myOrders.Remove(new object());
sys.Console.WriteLine("Contains {0}: {1}",tmpOrd.Number ,myOrders.Contains(tmpOrd.Number));
}
// error CS1502: The best overloaded method match for 'Orders.Contains(OrderNumber)' has some invalid arguments
// Scommenta la linea di codice per verificare che il metodo tipizzato funziona
//myOrders.Contains(new object());
{
myOrders[new OrderNumber()] = null;
sysCols.DictionaryEntry[] vetPair = new sysCols.DictionaryEntry[20]; // Questo Orders NON implementa un Entry tipizzato
myOrders.CopyTo(vetPair, 0);
sys.Console.WriteLine(vetPair.Length);
}
{
string[] vetOrd = new string[20];
// error CS1502: The best overloaded method match for 'Orders.Contains(OrderNumber)' has some invalid arguments
// Scommenta la linea di codice per verificare che il metodo tipizzato funziona
//myOrders.CopyTo(vetOrd, 0);
}
//
// Esercito i metodi non tipizzati
//
sysCols.IDictionary aDict = myOrders;
{
Order tmpOrd = new Order();
aDict[tmpOrd.Number] = tmpOrd;
// Scommenta la linea di codice e verifica che l'evento viene intercettato solo a Run-Time
//aDict[tmpOrd.Number] = new object();
}
{
Order tmpOrd = new Order();
aDict.Add(tmpOrd.Number, tmpOrd);
}
// Scommenta la linea di codice e verifica che l'evento viene intercettato solo a Run-Time
aDict.Add(123, "Arbracadabra");
{
Order tmpOrd = new Order();
aDict.Add(tmpOrd.Number, tmpOrd);
object tmpObj = tmpOrd.Number;
aDict.Remove(tmpObj);
}
// Scommenta la linea di codice per verificare che l'evento OnValidate intercetta
// l'errore solo a Run-Time
//aDict.Remove(new object());
return;
}
}