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())); }