public class Logger
    {
        private static Hashtable _logListHash = Hashtable.Synchronized(new Hashtable());

        public static void AddLog(object source, string log)
        {
            Type type = source.GetType();
            lock(type)
            {            
                if(!_logListHash.ContainsKey(type))
                {
                    string newLogString = string.Empty;
                    _logListHash[type] = newLogString;
                }
                
                string logString = (string)_logListHash[type];
                logString += log;
                _logListHash[type] = logString;
            }
        }

        public static ICollection GetLogSourceList()
        {
            return _logListHash.Keys;
        }

        public static string GetLog(Type type)
        {
            if(!_logListHash.ContainsKey(type))
                return "";
            return (string)_logListHash[type];
        }
    }

public sealed class Logger {
    private Logger() {}

    private static Hashtable _logs = Hashtable.Synchronized(new Hashtable());

    public static void AddLog(Type sourceType, string log) {
        StringBuilder sb = getStringBuilder(sourceType, true);
        lock (sb) {
            sb.Append(log);
        }
    }

    public static ICollection LogSourceList {
        get { return _logs.Keys; }
    }

    public static string GetLog(Type sourceType) {
        StringBuilder sb = getStringBuilder(sourceType, false);
        if (sb != null) {
            lock (sb) {
                return sb.ToString();
            }
        } else {
            return string.Empty;
        }
    }

    private static StringBuilder getStringBuilder(Type sourceType, bool autoCreate) {
        StringBuilder sb = (StringBuilder)_logs[sourceType];
        if (sb == null && autoCreate) {
            lock (sourceType) {
                sb = (StringBuilder)_logs[sourceType];
                if (sb == null) {
                    sb = new StringBuilder();
                    _logs.Add(sourceType, sb);
                }
            }
        }
        return sb;
    }
}

А>Набросал вот простенький класс для логгирования в многопоточном приложении. Несколько смущает его простота и место, где я делаю lock(type). Покритикуйте, пожалуйста

А>    public class Logger
А>    {
А>        public static void AddLog(object source, string log)
А>        {
А>            Type type = source.GetType();
А>            lock(type)
А>            {            
А>                if(!_logListHash.ContainsKey(type))
А>                {
А>                    string newLogString = string.Empty;
А>                    _logListHash[type] = newLogString;
А>                }
                
А>                string logString = (string)_logListHash[type];
А>                logString += log;
А>                _logListHash[type] = logString;
А>            }
А>        }
А>

    private static Hashtable _logListHash = new Hashtable();
    public static void AddLog(object source, string log)
        {
            Type type = source.GetType();
            lock( _logListHash.SyncRoot )
            {            
                string temp = _logListHash[type] as string;
                if ( temp == null )
                {
                    _logListHash.Add( type, log );
                    return;
                }
                _logLishHash[type]= temp + log;
            }