public IrcUser(IrcClient irc, string nick, IrcChannel chan)
     : this(irc)
 {
     m_nick = nick;
     m_comChans.Add(chan.Name, chan);
     irc.OnUserEncountered(this);
 }

 public UnbanTimer(IrcChannel chan, string mask, TimeSpan timeout)
 {
     Channel = chan;
     Mask = mask;
     m_timer = new Timer(timeout.TotalMilliseconds);
     m_timer.Elapsed += OnTick;
     m_timer.AutoReset = false;
     chan.AddUnbanTimer(this);
     m_timer.Start();
 }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="voteQuestion">The string of the vote.</param>
        /// <param name="channel">The channel where the vote takes place.</param>
        /// <param name="lifeSpan">If null, the vote lasts indefinitely. Else sets the time the vote lasts before ending (seconds)</param>
        public Vote(string voteQuestion, IrcChannel channel, int lifeSpan)
        {
            m_Vote = voteQuestion;
            m_Chan = channel;
            m_CreationTime = DateTime.Now;

            m_Timer = new Timer(lifeSpan * 1000);
            m_Timer.AutoReset = false;
            m_Timer.Start();
            m_Timer.Elapsed += m_Timer_Elapsed;
        }

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

 /// <summary>
 /// Indicates wether or not this User is on the specified channel.
 /// </summary>
 public bool IsOn(IrcChannel chan)
 {
     return IsOn(chan.Name);
 }

 /// <summary>
 /// Fires when the Client receives any kind of CTCP request. 
 /// Automatically replies to the VERSION request with the content of the Version variable
 /// if not overridden.
 /// </summary>
 /// <param name="user">The User who sent the text</param>
 /// <param name="chan">The Channel where it was sent (can be null)</param>
 /// <param name="request">The request type (such as VERSION)</param>
 /// <param name="args">The text which was sent in addition to the request</param>
 protected virtual void OnCtcpRequest(IrcUser user, IrcChannel chan, string request, string args)
 {
     if (request.ToUpper() == "VERSION" && Version != "")
         CommandHandler.CtcpReply(user.Nick, "VERSION", Version);
 }

 /// <summary>
 /// Fires when the Client receives a PRIVMSG which was directed to a Channel.
 /// </summary>
 protected virtual void OnChannelMsg(IrcUser user, IrcChannel chan, StringStream text)
 {
 }

 protected virtual void OnCannotJoin(IrcChannel chan, string reason)
 {
 }

 /// <summary>
 /// Fires when the BanList for a Channel has been sent completely.
 /// </summary>
 protected virtual void OnBanListComplete(IrcChannel chan)
 {
 }

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

 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 CtcpReplyNotify(IrcUser user, IrcChannel chan, string reply, string args)
 {
     OnCtcpReply(user, chan, reply, args);
 }

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

 internal virtual void ChanCreationTimeNotify(IrcChannel chan, DateTime creationTime)
 {
     chan.ChanCreationTimeSentNotify(creationTime);
     OnChanCreationTime(chan, creationTime);
 }

 internal void CannotJoinNotify(IrcChannel channel, string reason)
 {
     OnCannotJoin(channel, reason);
 }

 internal void UserLeftChannelNotify(IrcChannel chan, IrcUser user, string reason)
 {
     OnUserLeftChannel(chan, user, reason);
 }

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

 internal void JoinNotify(IrcUser user, string name)
 {
     if (!m_loggedIn)
         m_loggedIn = true;
     IrcChannel chan;
     if (user == Me)
     {
         Me.DeleteChannel(name);
     }
     if ((chan = GetChannel(name)) == null)
     {
         Send("mode " + name);
         if (user != m_me)
         {
             foreach (IrcChannel c in m_me)
             {
                 user.AddChannel(c);
                 c.AddUser(user);
                 c.DeleteUser(user);
             }
             m_me = user;
             m_Users.Remove(m_me.Nick);
         }
         chan = new IrcChannel(this, name);
     }
     user.AddChannel(chan);
     chan.UserJoinedNotify(user);
     OnJoin(user, chan);
 }

 /// <summary>
 /// Fires when an already established BanEntry has been sent (raw 367).
 /// </summary>
 protected virtual void OnBanListEntry(IrcChannel chan, BanEntry entry)
 {
 }

 internal void KickNotify(IrcUser user, IrcChannel chan, IrcUser target, string reason)
 {
     OnKick(user, chan, target, reason);
     chan.UserKickedNotify(user, target, reason);
     target.DeleteChannel(chan.Name);
     CheckUserKnown(target);
 }