C#

SJ_Phoenix wrote:

Does C# 3 gets delivered together with .net framework 3.0

-Yoyosh- wrote:

I read many MSDN articles

lsugirljte wrote:

Can you override inherited delegates? If so, how?

 The OnRowUpdating method also allows derived classes to handle the event without 
attaching a delegate. This is the preferred technique for handling the event in a derived class.

class GridView
{
   public event RowUpdatingDelegate RowUpdating;
}

class MyMultiGridView : GridView
{
  public new event RowUpdatingDelegate RowUpdating;
}

GridView g = new GridView();
g.RowUpdating += ... // Won't work

MyMultiGridView g = new MyMultiGridView();
g.RowUpdating += ... // This will work.

    public class SafeDictionary<TKey, TValue> : IDictionary<TKey, TValue> 
    { 
        private readonly object syncRoot = new object(); 
        private Dictionary<TKey, TValue> d = new Dictionary<TKey, TValue>(); 


        #region IDictionary<TKey,TValue> Members 


        public void Add(TKey key, TValue value) 
        { 
            lock (syncRoot) 
            { 
                d.Add(key, value); 
            } 
        } 


        public bool ContainsKey(TKey key) 
        { 
            return d.ContainsKey(key); 
        } 


        public ICollection<TKey> Keys 
        { 
            get 
            { 
                lock (syncRoot) 
                { 
                    return d.Keys; 
                } 
            } 
        } 


        public bool Remove(TKey key) 
        { 
            lock (syncRoot) 
            { 
                return d.Remove(key); 
            } 
        } 


        public bool TryGetValue(TKey key, out TValue value) 
        { 
            lock (syncRoot) 
            { 
                return d.TryGetValue(key, out value); 
            } 
        } 


        public ICollection<TValue> Values 
        { 
            get 
            { 
                lock (syncRoot) 
                { 
                    return d.Values; 
                } 
            } 
        } 


        public TValue this[TKey key] 
        { 
            get 
            { 
                return d[key]; 
            } 
            set 
            { 
                lock (syncRoot) 
                { 
                    d[key] = value; 
                } 
            } 
        } 


        #endregion 


        #region ICollection<KeyValuePair<TKey,TValue>> Members 


        public void Add(KeyValuePair<TKey, TValue> item) 
        { 
            lock (syncRoot) 
            { 
                ((ICollection<KeyValuePair<TKey, TValue>>)d).Add(item); 
            } 
        } 


        public void Clear() 
        { 
            lock (syncRoot) 
            { 
                d.Clear(); 
            } 
        } 


        public bool Contains(KeyValuePair<TKey, TValue> item) 
        { 
            return ((ICollection<KeyValuePair<TKey, 
TValue>>)d).Contains(item); 
        } 


        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int 
arrayIndex) 
        { 
            lock (syncRoot) 
            { 
                ((ICollection<KeyValuePair<TKey, TValue>>)d).CopyTo(array, 
arrayIndex); 
            } 
        } 


        public int Count 
        { 
            get 
            { 
                return d.Count; 
            } 
        } 


        public bool IsReadOnly 
        { 
            get { return false; } 
        } 


        public bool Remove(KeyValuePair<TKey, TValue> item) 
        { 
            lock (syncRoot) 
            { 
                return ((ICollection<KeyValuePair<TKey, 
TValue>>)d).Remove(item); 
            } 
        } 


        #endregion 


        #region IEnumerable<KeyValuePair<TKey,TValue>> Members 


        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() 
        { 
            return ((ICollection<KeyValuePair<TKey, 
TValue>>)d).GetEnumerator(); 
        } 


        #endregion 


        #region IEnumerable Members 


        System.Collections.IEnumerator 
System.Collections.IEnumerable.GetEnumerator() 
        { 
            return ((System.Collections.IEnumerable)d).GetEnumerator(); 
        } 


        #endregion 
    }