public IrcClient(Encoding encoding)
        {
            Reset();
            m_Users = new Dictionary<string, IrcUser>(StringComparer.InvariantCultureIgnoreCase);
            m_unbanTimers = new Dictionary<string, UnbanTimer>();

            m_me = new IrcUser(this);
            m_client = new Client(this);
            m_CommandHandler = new IrcCommandHandler(this);
            m_dcc = new Dcc.Dcc(this);
            protHandler = new IrcProtocolHandler(this, encoding);
        }

 public AutoVoiceUser(IrcUser user,IrcChannel channel)
 {
     User = user;
     Channel = channel;
     _voiceTimer.Elapsed += delegate
                               {
                                   if(!user.Modes.Contains("v"))
                                   user.IrcClient.CommandHandler.Mode(Channel, "+v", User);
                                   _voiceTimer.Stop();
                               };
     _voiceTimer.Start();
 }

 internal void OnUserParsed(IrcUser user)
 {
     AuthMgr.OnNewUser(user);
 }

        public IrcUser GetOrCreateUser(string mask)
        {
            IrcUser user = null;
            var nick = "";
            if (mask.IndexOf("!") > -1)
                nick = mask.Split('!')[0];
            else
                nick = mask;

            user = GetUser(nick);

            if (user == null)
            {
                user = new IrcUser(this, mask);
                OnUserEncountered(user);
            }
            else if (!user.IsParsed)
            {
                user.Parse(mask);
            }

            return user;
        }

 protected internal virtual void OnUserEncountered(IrcUser user)
 {
     m_Users.Remove(user.Nick);
     m_Users.Add(user.Nick, user);
     if (AuthMgr != null && AutoResolveAuth)
     {
         // resolve
         AuthMgr.ResolveAuth(user);
     }
 }

 /// <summary>
 /// Fires when the Client receives any kind of CTCP reply.
 /// </summary>
 /// <param name="user">The User who sent the text</param>
 /// <param name="channel">The Channel where it was sent (can be null)</param>
 /// <param name="reply">The reply type (such as VERSION)</param>
 /// <param name="args">The text which was sent in addition to the reply</param>
 protected virtual void OnCtcpReply(IrcUser user, IrcChannel chan, string reply, string args)
 {
 }

 /// <summary>
 /// Fires when a User deletes a Channel flag from another User.
 /// </summary>
 protected virtual void OnFlagDeleted(IrcUser user, IrcChannel chan, Privilege priv, IrcUser target)
 {
 }

 internal void TopicNotify(IrcUser user, IrcChannel chan, string text, bool initial)
 {
     chan.TopicChangedNotify(user, text, initial);
     OnTopic(user, chan, text, initial);
 }

 internal void UsersAddedNotify(IrcChannel chan, IrcUser[] users)
 {
     chan.UsersAddedNotify(users);
     OnUsersAdded(chan, users);
 }

 internal void PartNotify(IrcUser user, IrcChannel chan, string reason)
 {
     OnPart(user, chan, reason);
     chan.UserPartedNotify(user, reason);
     user.DeleteChannel(chan.Name);
     CheckUserKnown(user);
 }

 internal void QuitNotify(IrcUser user, string reason)
 {
     foreach (var chan in user.Channels.Values)
     {
         chan.UserLeftNotify(user, reason);
     }
     OnQuit(user, reason);
     m_Users.Remove(user.Nick);
     if (user == Me)
     {
         m_client.Disconnect();
     }
 }

 internal void CtcpRequestNotify(IrcUser user, IrcChannel chan, string request, string text)
 {
     if (request.ToUpper() == "DCC" && chan == null)
     {
         Dcc.Handle(user, text);
     }
     OnCtcpRequest(user, chan, request, text);
 }

 internal void FlagDeletedNotify(IrcUser user, IrcChannel chan, Privilege priv, IrcUser target)
 {
     chan.FlagDeletedNotify(user, priv, target);
     OnFlagDeleted(user, chan, priv, target);
 }

 internal void CtcpReplyNotify(IrcUser user, IrcChannel chan, string reply, string args)
 {
     OnCtcpReply(user, chan, reply, args);
 }

 internal void CheckUserKnown(IrcUser user)
 {
     if (user.Channels.Count == 0)
     {
         OnUserDisappeared(user);
         m_Users.Remove(user.Nick);
     }
 }

 internal void ChannelMsgNotify(IrcUser user, IrcChannel chan, StringStream text)
 {
     chan.MsgReceivedNotify(user, text);
     OnChannelMsg(user, chan, text);
 }

 internal void AuthNotify(IrcUser user)
 {
     var evt = AuthResolved;
     if (evt != null)
     {
         evt(user);
     }
 }

 public virtual bool TriggersCommand(IrcUser user, IrcChannel chan, StringStream input)
 {
     return input.ConsumeNext(CommandHandler.RemoteCommandPrefix);
 }

 internal void QueryMsgNotify(IrcUser user, StringStream text)
 {
     OnQueryMsg(user, text);
 }

 internal void InviteNotify(IrcUser user, string chan)
 {
     OnInvite(user, chan);
 }