public void Remove(ManagedObjectName objectName)
{
lock (this)
{
InnerHashtable.Remove(objectName);
}
}
object IDictionary.this[object key] {
get {
object currentValue = InnerHashtable[key];
OnGet(key, currentValue);
return(currentValue);
}
set {
OnValidate(key, value);
bool keyExists = true;
Object temp = InnerHashtable[key];
if (temp == null)
{
keyExists = InnerHashtable.Contains(key);
}
OnSet(key, temp, value);
InnerHashtable[key] = value;
try {
OnSetComplete(key, temp, value);
}
catch {
if (keyExists)
{
InnerHashtable[key] = temp;
}
else
{
InnerHashtable.Remove(key);
}
throw;
}
}
}
/// <summary>
/// Copy Constructor
/// </summary>
/// <param name="propertiesDictionary">properties to copy</param>
/// <remarks>
/// <para>
/// Initializes a new instance of the <see cref="ReadOnlyPropertiesDictionary" /> class.
/// </para>
/// </remarks>
public ReadOnlyPropertiesDictionary(ReadOnlyPropertiesDictionary propertiesDictionary)
{
foreach (DictionaryEntry entry in propertiesDictionary)
{
InnerHashtable.Add(entry.Key, entry.Value);
}
}
public fk_columns(DataRow row)
{
foreach (string field in fields.Split(','))
{
InnerHashtable.Add(field, row[field]);
}
}
public void Add(ManagedObjectName objectName, Entry instance)
{
lock (this)
{
InnerHashtable.Add(objectName, instance);
}
}
/// <summary>
/// 根据表名获取字段集合
/// </summary>
/// <param name = "tableName">表名</param>
/// <returns>字段集合</returns>
public virtual List <TableColumnCondition> Get(string tableName)
{
if (InnerHashtable.Contains(tableName))
{
return((List <TableColumnCondition>)InnerHashtable[tableName]);
}
return(new List <TableColumnCondition>());
}
// Instance Methods
public void Add(string key, Symbol value)
{
if (InnerHashtable.Contains(key))
{
Debug.Fail(Owner.FullName + " already holds " + key);
}
InnerHashtable.Add(key, value);
}
/// <summary>
/// 根据字段名获取排序类型
/// </summary>
/// <param name = "fieldName">字段名</param>
/// <returns>排序类型</returns>
public virtual OrderByType Get(string fieldName)
{
if (InnerHashtable.Contains(fieldName))
{
return((OrderByType)InnerHashtable[fieldName]);
}
return(OrderByType.Asc);
}
/// <summary>
/// See <see cref="IDictionary.Add"/>
/// </summary>
/// <param name="key">the key</param>
/// <param name="value">the value to store for the key</param>
/// <remarks>
/// <para>
/// Store a value for the specified <see cref="String"/> <paramref name="key"/>.
/// </para>
/// </remarks>
/// <exception cref="ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
void IDictionary.Add(object key, object value)
{
if (!(key is string))
{
throw new ArgumentException("key must be a string", "key");
}
InnerHashtable.Add(key, value);
}
public string this[T code]
{
get
{
return(InnerHashtable.ContainsKey(code)
? InnerHashtable[code].ToString()
: "Không tìm thấy thông tin ứng với mã lỗi");
}
}
/// <include file='doc\DictionaryBase.uex' path='docs/doc[@for="DictionaryBase.IDictionary.Remove"]/*' />
void IDictionary.Remove(object key)
{
Object temp = InnerHashtable[key];
OnValidate(key, temp);
OnRemove(key, temp);
InnerHashtable.Remove(key);
OnRemoveComplete(key, temp);
}
public void Add(string name, object value)
{
if (string.IsNullOrEmpty(name))
{
return;
}
InnerHashtable.Add(name, value);
}
/// <summary>
/// 删除字段排序
/// </summary>
/// <param name = "fieldName">字段名</param>
public virtual void Remove(string fieldName)
{
if (InnerHashtable.Contains(fieldName))
{
var index = innerValues.IndexOf((OrderByType)InnerHashtable[fieldName]);
innerValues.RemoveAt(index);
innerKeys.Remove(fieldName);
InnerHashtable.Remove(fieldName);
}
}
/// <summary>
/// 删除字段排序
/// </summary>
/// <param name = "tableName">表名</param>
public virtual void Remove(string tableName)
{
if (InnerHashtable.Contains(tableName))
{
var index = innerValues.IndexOf((List <TableColumnCondition>)InnerHashtable[tableName]);
innerValues.RemoveAt(index);
innerKeys.Remove(tableName);
InnerHashtable.Remove(tableName);
}
}
public ContextMenuStripGroup this[string key]
{
get
{
if (!InnerHashtable.ContainsKey(key))
{
InnerHashtable[key] = new ContextMenuStripGroup(key);
}
return(InnerHashtable[key] as ContextMenuStripGroup);
}
}
void IDictionary.Add(object key, object value)
{
OnValidate(key, value);
OnInsert(key, value);
InnerHashtable.Add(key, value);
try {
OnInsertComplete(key, value);
}
catch {
InnerHashtable.Remove(key);
throw;
}
}
/// <summary>
/// Adds the data the dictionary from reader
/// </summary>
public void AddData(SqlDataReader reader)
{
while (reader.Read())
{
string key = reader.GetString(1);
if (Contains(key))
{
InnerHashtable.Remove(key);
}
InnerHashtable.Add(key, new App(reader));
}
reader.Close();
}
/// <summary>
/// Construct a JsonObject from a IDictionary
/// </summary>
public JsonObject(IDictionary members)
{
foreach (DictionaryEntry entry in DictionaryHelper.GetEntries(members))
{
if (entry.Key == null)
{
throw new InvalidMemberException();
}
InnerHashtable.Add(entry.Key.ToString(), entry.Value);
}
_nameIndexList = new ArrayList(members.Keys);
}
/// <summary>
/// 增加字段集合
/// </summary>
/// <param name = "tableName">表名</param>
/// <param name = "tableColumnList">字段集合</param>
public virtual void Add(string tableName, List <TableColumnCondition> tableColumnList)
{
if (InnerHashtable.Contains(tableName))
{
var index = innerValues.IndexOf((List <TableColumnCondition>)InnerHashtable[tableName]);
innerValues[index] = tableColumnList;
InnerHashtable[tableName] = tableColumnList;
}
else
{
innerKeys.Add(tableName);
InnerHashtable[tableName] = tableColumnList;
innerValues.Add(tableColumnList);
}
}
public IPAddresses(string filePath)
{
string line;
string[] words;
StreamReader streamReader = File.OpenText(filePath);
while (streamReader.Peek() != -1)
{
line = streamReader.ReadLine();
words = line.Split(',');
InnerHashtable.Add(words[0], words[1]);
}
streamReader.Close();
}
/// <summary>
/// 增加排序字段
/// </summary>
/// <param name = "fieldName">字段名</param>
/// <param name = "orderByType">排序类型</param>
public virtual void Add(string fieldName, OrderByType orderByType)
{
if (InnerHashtable.Contains(fieldName))
{
var index = innerValues.IndexOf((OrderByType)InnerHashtable[fieldName]);
innerValues[index] = orderByType;
InnerHashtable[fieldName] = orderByType;
}
else
{
innerKeys.Add(fieldName);
InnerHashtable[fieldName] = orderByType;
innerValues.Add(orderByType);
}
}
/// <summary>
/// Construct a JObject from a IDictionary
/// </summary>
public JsonObject(IDictionary members)
{
// FIXME: Use IDictionaryEnumerator.Entry instead and enumerate manually (faster and more robust).
// See comment in DictionaryExporter for details.
foreach (DictionaryEntry entry in members)
{
if (entry.Key == null)
{
throw new InvalidMemberException();
}
InnerHashtable.Add(entry.Key.ToString(), entry.Value);
}
_nameIndexList = new ArrayList(members.Keys);
}
void IDictionary.Remove(object key)
{
if (InnerHashtable.Contains(key))
{
Object temp = InnerHashtable[key];
OnValidate(key, temp);
OnRemove(key, temp);
InnerHashtable.Remove(key);
try {
OnRemoveComplete(key, temp);
}
catch {
InnerHashtable.Add(key, temp);
throw;
}
}
}
/// <summary>
/// See <see cref="ICollection.CopyTo"/>
/// </summary>
/// <param name="array"></param>
/// <param name="index"></param>
void ICollection.CopyTo(Array array, int index)
{
InnerHashtable.CopyTo(array, index);
}
/// <summary>
/// Remove all properties from the properties collection
/// </summary>
/// <remarks>
/// <para>
/// Remove all properties from the properties collection
/// </para>
/// </remarks>
public override void Clear()
{
InnerHashtable.Clear();
}
/// <summary>
/// See <see cref="IDictionary.Contains"/>
/// </summary>
/// <param name="key">the key to lookup in the collection</param>
/// <returns><c>true</c> if the collection contains the specified key</returns>
/// <remarks>
/// <para>
/// Test if this collection contains a specified key.
/// </para>
/// </remarks>
bool IDictionary.Contains(object key)
{
return(InnerHashtable.Contains(key));
}
/// <summary>
/// See <see cref="IDictionary.Remove"/>
/// </summary>
/// <param name="key">the key to remove</param>
/// <remarks>
/// <para>
/// Remove the entry with the specified key from this dictionary
/// </para>
/// </remarks>
void IDictionary.Remove(object key)
{
InnerHashtable.Remove(key);
}
/// <summary>
/// See <see cref="IDictionary.GetEnumerator"/>
/// </summary>
/// <returns>an enumerator</returns>
/// <remarks>
/// <para>
/// Returns a <see cref="IDictionaryEnumerator"/> over the contest of this collection.
/// </para>
/// </remarks>
IDictionaryEnumerator IDictionary.GetEnumerator()
{
return(InnerHashtable.GetEnumerator());
}
/// <summary>
/// Remove the entry with the specified key from this dictionary
/// </summary>
/// <param name="key">the key for the entry to remove</param>
/// <remarks>
/// <para>
/// Remove the entry with the specified key from this dictionary
/// </para>
/// </remarks>
public void Remove(string key)
{
InnerHashtable.Remove(key);
}
IDictionaryEnumerator IDictionary.GetEnumerator()
{
return(new DictionaryEnumerator(this, InnerHashtable.GetEnumerator()));
}
