You need to use a
Hashtable
in your project that allows you to set
the maximum and/or minimum number of elements that it can hold.
Use the MaxMinSizeHashtable
class defined here.
This class allows a definition of a maximum and a minimum size beyond
which this MaxMinSizeHashtable
cannot grow or
shrink:
using System; using System.Collections; [Serializable] public class MaxMinSizeHashtable : Hashtable { public MaxMinSizeHashtable( ) : base(10) { } public MaxMinSizeHashtable(int minSize, int maxSize) : base(maxSize) { if (minSize >= 0 && maxSize > 0) { this.minSize = minSize; this.maxSize = maxSize; } } protected int minSize = 0; protected int maxSize = 10; // Initial size for a regular Hashtable protected bool readOnly = false; public bool ReadOnly { get {return (readOnly);} set {readOnly = value;} } public override bool IsReadOnly { get {return readOnly;} } public override object this[object key] { get { return (base[key]); } set { if (!readOnly) { if (key is long) { if (long.Parse(key.ToString( )) < maxSize && long.Parse(key.ToString( )) > minSize) { base[key] = value; } else { throw (new ArgumentOutOfRangeException("key", key, "The key is outside the minimum/maximum" + " boundaries.")); } } else { base[key] = value; } } else { throw (new ArgumentOutOfRangeException("value", value, "This Hashtable is currently set to read-only.")); } } } public override void Add(object key, object value) { if (!readOnly) { if (this.Count < maxSize) { base.Add(key, value); } else { throw (new ArgumentOutOfRangeException("value", value, "No more values can be added to this Hashtable, " + "until one is removed")); } } else { throw (new ArgumentOutOfRangeException("value", value, "This Hashtable is currently set to read-only.")); } } public override void Remove(object key) { if (!readOnly) { if (this.Count > minSize) { base.Remove(key); } else { throw (new InvalidOperationException( "No more values can be removed from this Hashtable, " + "until one is added")); } } else { throw (new NotSupportedException( "This Hashtable is currently set to read-only.")); } } public override void Clear( ) { if (!readOnly) { if (minSize == 0) { base.Clear( ); } else { throw (new InvalidOperationException( "Clearing this Hashtable would go below the minimum " + "size of " + minSize)); } } else { throw (new InvalidOperationException( "This Hashtable is currently set to read-only.")); } } }
The MaxMinSizeHashtable
class inherits from
Hashtable
and overrides the members that allow
Hashtable
values to be added, removed, and
modified. The overloaded constructor for the
MaxMinSizeHashtable
class is defined here:
public MaxMinSizeHashtable(intminSize
, intmaxSize
)
Its parameters are:
minSize
The smallest number of elements this class can contain
maxSize
The largest number of elements this class can contain
A public Boolean property called ReadOnly
has been
added to this class to allow or prevent the use of the
Add
, Remove
, and
Clear
methods.
The overloaded Add
method will add the object to
the MaxMinSizeHashtable
only when it is not
read-only and the current size is less than the
maxSize
field. If all tests pass, the value is
added to the MaxMinSizeHashtable
.
The overloaded Remove
method is overloaded to
validate that the size of the MaxMinSizeHashtable
does not fall below the number specific by the
minSize
field. The Clear
method
is also overridden to verify that the minSize
field is zero before this operation is allowed to proceed, since this
operation will leave zero elements in this
MaxMinSizeHashtable
.
As a final point, the overloaded constructor accepts
minSize
and
maxSize
as signed integers. Obviously the
MaxMinSizeHashtable
cannot have a negative size.
The reason for this is compliance with other .NET languages that may
use this class. The unsigned numeric types are not included in the
CLS; therefore, they are not CLS-compliant.
Consider what would happen if a Visual Basic .NET object—which
does not handle unsigned numeric types—tried to use this
object. If the MaxMinSizeHashtable
constructor
accepted only uint
types and a Visual Basic .NET
class attempted to instantiate an instance of the
MaxMinSizeHashtable
:
' Visual Basic .NET code Dim Table As New MaxMinSizeHashtable(2, 4)
the Visual Basic .NET compiler would complain that a value of type
Integer
could not be converted to a
System.UInt32
type. Visual Basic .NET has no
ability to convert types to and from unsigned types. To make this
object and many others in this book compliant, we choose to use
signed rather than unsigned numeric types where possible.