///
<summary>
///
A basic example which
simply echos all
///
public messages sent to
a channel.
///
It
is designed to demonstrate how to connect to an IRC
///
server and how to register event handlers.
///
</summary>
public
class Basic
{
///
<summary>
///
The
connection object is the focal point of the library.
///
It
used to retrieve references to the various library components.
///
</summary>
private
Connection connection;
///
<summary>
///
Create
a bot and register its handlers.
///
</summary>
public
Basic()
{
CreateConnection
();
//OnRegister tells us that we have
successfully established a connection with
//the server.
Once this is established we can join channels, check for
people
//online, or whatever.
connection.Listener.OnRegistered += new
RegisteredEventHandler
( OnRegistered );
//Listen for any messages sent to the channel
connection.Listener.OnPublic += new
PublicMessageEventHandler
( OnPublic );
//Listen for bot commands sent as
private messages
connection.Listener.OnPrivate += new
PrivateMessageEventHandler
( OnPrivate );
//Listen for notification that an error has ocurred
connection.Listener.OnError += new
ErrorMessageEventHandler
( OnError );
//Listen for notification that we are no longer connected.
connection.Listener.OnDisconnected += new
DisconnectedEventHandler
( OnDisconnected );
}
private
void CreateConnection()
{
//The hostname of the IRC server
string
server =
"sunray.sharkbite.org";
//The bot's nick on IRC
string
nick = "EchoBot";
//Fire up the Ident server for
those IRC networks
//silly enough to use it.
Identd.Start
(
nick );
//A ConnectionArgs contains all
the info we need to establish
//our connection with the IRC server and register our bot.
//This line uses the simplfied contructor and the default values.
//With this constructor the Nick, Real
Name, and User name are
//all set to the same value. It will use the default port
of 6667 and no server
//password.
ConnectionArgs cargs = new
ConnectionArgs
(nick, server);
//When creating a Connection two additional protocols may
be
//enabled: CTCP and DCC. In this example we will disable
them
//both.
connection = new Connection(
cargs, false, false );
//NOTE
//We could
have created multiple Connections to different IRC servers
//and each would process messages simultaneously and
independently.
//There is no fixed limit on how many Connection can be
opened at one time but
//it is important to realize that each runs in its own
Thread. Also,separate
event
//handlers are required for each connection, i.e. the
//same
OnRegistered
() handler cannot be used for different connection
//instances.
}
public
void start()
{
//Notice that by having the actual connect call here
//the constructor can add the necessary listeners before
//the connection process begins. If listeners are added
//after connecting they may miss certain events. the OnRegistered()
//event will certainly be missed.
try
{
//Calling Connect() will cause the
Connection object to open a
//socket to the IRC server and to spawn
its own thread.
In this
//separate thread it will listen for messages and send them
to the
//Listener for processing.
connection.Connect
();
Console.WriteLine
("Echobot connected.");
//The main thread ends here but the Connection's thread is
still alive.
//We are now in a passive mode
waiting for events to arrive.
}
catch( Exception e )
{
Console.WriteLine
("Error during connection process.");
Console.WriteLine
( e );
Identd.Stop
();
}
}
public
void OnRegistered()
{
//We have to catch errors in our delegates because Thresher
purposefully
//does not handle them for us.
Exceptions will cause the library to exit if they are not
//caught.
try
{
//Don't need this anymore in this example but this can be
left running
//if you want.
Identd.Stop
();
//The connection is ready so lets
join a channel.
//We can join any number of channels simultaneously but
//one will do for now.
//All commands are sent to IRC using the Sender object
//from the Connection.
connection.Sender.Join
("#thresher");
}
catch( Exception e )
{
Console.WriteLine
("Error in OnRegistered():
" + e ) ;
}
}
public
void OnPublic( UserInfo user, string
channel, string message )
{
//Echo back any public messages
connection.Sender.PublicMessage
( channel,user.Nick + " said, " + message );
}
public
void OnPrivate( UserInfo user,string message )
{
//Quit IRC if someone sends us a 'die' message
if( message ==
"die" )
{
connection.Disconnect
("Bye");
}
}
public
void OnError( ReplyCode code, string
message)
{
//All anticipated errors have a numeric code. The custom
Thresher ones start at 1000 and
//can be found in the ErrorCodes class. All the others are determined by the IRC
spec
//and can be found in RFC2812Codes.
Console.WriteLine
("An error of type " + code + " due to "
+ message + " has occurred.");
}
public
void OnDisconnected()
{
//If this disconnection was involutary
then you should have received an error
//message ( from OnError() ) before this was called.
Console.WriteLine
("Connection to the server has been closed.");
}
}
