class Sample : IDisposable
{
    // Dumps errors from a scheduler to the console.
    class ErrorReporter
    {
        private readonly Scheduler scheduler_;

        public ErrorReporter(Scheduler scheduler)
        {
            (scheduler_ = scheduler).Error += OnSchedulerError;
        }

        private void OnSchedulerError(
            object scheduler, SessionErrorEventArgs args)
        {
            Console.WriteLine(
                "Scheduler reported error for session {0}: {1}",
                args.Session, args.Reason);
        }
    }

    // Dumps session state changes to the console.
    class SessionStateChangeDetector
    {
        private readonly Session session_;

        public SessionStateChangeDetector(Session session)
        {
            (session_ = session).StateChangeEvent += OnStateChange;
        }

        private void OnStateChange(
            object session,
            Session.StateChangeEventArgs args)
        {
            Console.WriteLine(
                "Session {0} changed its state from {1} to {2}.",
                session, args.PrevState, args.NewState);
        }
    }

    // Samples configuration parameters.

    const string acceptorSideId_ = "Acceptor";
    const string initiatorSideId_ = "Initiator";

    const ProtocolVersion protocol_ = ProtocolVersion.FIX44;
    const bool seqNumberLogonPolicy_ = true;

    private Scheduler scheduler_;
    private ErrorReporter errorReporter_;

    private Session acceptor_;
    private Session initiator_;

    // Sample schedules only initiator, therefore, its
    // state will be traced to make sure the scheduler works.
    private SessionStateChangeDetector initiatorStateTracer_;

    public Sample()
    {
        ConstructScheduler();
        ConstructSessions();
    }

    private void ConstructSessions()
    {
        acceptor_ = new Session(
            acceptorSideId_, initiatorSideId_,
            protocol_,
            seqNumberLogonPolicy_);

        initiator_ = new Session(
            initiatorSideId_, acceptorSideId_,
            protocol_,
            seqNumberLogonPolicy_);

        initiatorStateTracer_ =
            new SessionStateChangeDetector(
            initiator_);
    }

    private void ConstructScheduler()
    {
        scheduler_ = new Scheduler();
        errorReporter_ = new ErrorReporter(scheduler_);
    }

    ~Sample()
    {
        CleanUp();
    }

    public void Dispose()
    {
        CleanUp();
        GC.SuppressFinalize(this);
    }

    private void CleanUp()
    {
        scheduler_.Dispose();

        initiator_.Dispose();
        acceptor_.Dispose();
    }

    // Carries the sample out.
    public void Run()
    {
        // Acceptor is being maintained manually.
        // Therefore, reset of sequence numbers
        // must be done manually before logon.
        acceptor_.ResetLocalSequenceNumbers();

        // Comment this call if you want to check
        // how the scheduler notifies about errors.
        acceptor_.LogonAsAcceptor();

        SessionSchedule scheduleForInitiator =
            ConstructShortTimeActivitySchedule();

        // Let's play the party..

        scheduler_.Register(
            initiator_,
            scheduleForInitiator,
            new InitiatorConnectionSettings("localhost", 4500));

        Console.WriteLine(
            "Session {0} scheduled for automatic connection.",
            initiator_);

        // Since a session is initially in disconnected state,
        // we can't simply wait for logout. Instead, we have
        // to give time for the scheduler to activate the session.
        // The best and simplest approach is to wait till time
        // of logout, as it's specified in the constructed schedule.

        PauseUntil(
            scheduleForInitiator.LogoutTimes[
            (int)DateTime.Now.DayOfWeek]);

        // Make sure that initiator is shutdown.
        WaitUntilLogout(initiator_);

        // Don't forget that once initiator disconnects from
        // the acceptor, the acceptor starts waiting for the next logon.
        // Since we manage it manually, we have to call logout.

        acceptor_.Logout();
        WaitUntilLogout(acceptor_);
    }

    // Constructs schedule with short time activity in 30 seconds.
    // Also logon time is delayed for a couple of seconds to demonstrate
    // that scheduler will connect a session only when logon event occurs.
    private static SessionSchedule
        ConstructShortTimeActivitySchedule()
    {
        const int logonDelayInSeconds = 5;
        const int sessionDurationInSeconds = 30;

        TimeSpan logonTime =
            DateTime.Now.TimeOfDay.Add(
            new TimeSpan(0, 0, logonDelayInSeconds));

        TimeSpan logoutTime = logonTime.Add(
            new TimeSpan(0, 0, sessionDurationInSeconds));

        return new SessionSchedule(
            DayOfWeek.Sunday,
            DayOfWeek.Saturday,
            logonTime,
            logoutTime,
            SessionDuration.Day,
            SequenceNumberResetPolicy.Daily);
    }

    private static void PauseUntil(TimeSpan timeOfDay)
    {
        System.Threading.Thread.Sleep(
            timeOfDay.Subtract(DateTime.Now.TimeOfDay));
    }

    private static void WaitUntilLogout(Session session)
    {
        const int oneSecondPause = 1000;

        while (session.State != Session.SessionState.DISCONNECTED)
            System.Threading.Thread.Sleep(oneSecondPause);
    }
}

static class Program
{
    private static void Initialize()
    {
        const int connectionPort = 4500;

        Engine.Init(connectionPort);

        Engine.Instance.Settings.ReconnectAttempts = 2;
        Engine.Instance.Settings.ReconnectInterval = 1;
    }

    private static void CleanUp()
    {
        if (Engine.IsInitialized())
            Engine.Instance.Shutdown();
    }

    public static void Main(String[] args)
    {
        try
        {
            Initialize();

            using (Sample sample = new Sample())
            {
                sample.Run();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine();

            Console.WriteLine(
                "Error while executing sample: {0}",
                ex);
        }
        finally
        {
            CleanUp();
        }
    }
}

Class Sample

    Implements IDisposable

    ' Dumps errors from scheduler to the console.
    Class ErrorReporter

        Private ReadOnly scheduler_ As Scheduler

        Public Sub New(ByVal scheduler As Scheduler)
            scheduler_ = scheduler
            AddHandler scheduler_.Error, AddressOf OnSchedulerError
        End Sub

        Private Sub OnSchedulerError(ByVal scheduler As Object, ByVal args As SessionErrorEventArgs)
            Console.WriteLine("Scheduler reported error for session {0}: {1}", args.Session, args.Reason)
        End Sub
    End Class

    ' Dumps session state changes to the console.
    Class SessionStateChangeDetector

        Private ReadOnly session_ As Session

        Public Sub New(ByRef session As Session)
            session_ = session
            AddHandler session_.StateChangeEvent, AddressOf OnStateChange
        End Sub

        Private Sub OnStateChange(ByVal session As Object, ByVal args As Session.StateChangeEventArgs)
            Console.WriteLine("Session {0} changed its state from {1} to {2}.", session, args.PrevState, args.NewState)
        End Sub
    End Class

    ' Samples configuration parameters.

    Const acceptorSideId_ As String = "Acceptor"
    Const initiatorSideId_ As String = "Initiator"

    Const protocol_ As ProtocolVersion = ProtocolVersion.FIX44
    Const seqNumberLogonPolicy_ As Boolean = True

    Private scheduler_ As Scheduler
    Private errorReporter_ As ErrorReporter

    Private acceptor_ As Session
    Private initiator_ As Session

    ' Sample schedules only initiator, therefore its
    ' state will be traced to make sure scheduler works.
    Private initiatorStateTracer_ As SessionStateChangeDetector

    Public Sub Sample()
        ConstructScheduler()
        ConstructSessions()
    End Sub

    Private Sub ConstructSessions()

        acceptor_ = New Session(acceptorSideId_, initiatorSideId_, protocol_, seqNumberLogonPolicy_)
        initiator_ = New Session(initiatorSideId_, acceptorSideId_, protocol_, seqNumberLogonPolicy_)
        initiatorStateTracer_ = New SessionStateChangeDetector(initiator_)
    End Sub

    Private Sub ConstructScheduler()
        scheduler_ = New Scheduler()
        errorReporter_ = New ErrorReporter(scheduler_)
    End Sub

    Protected Overrides Sub Finalize()
        Try
            CleanUp()
        Finally
            MyBase.Finalize()
        End Try
    End Sub

    Public Sub Dispose() Implements IDisposable.Dispose
        CleanUp()
        GC.SuppressFinalize(Me)
    End Sub

    Private Sub CleanUp()
        scheduler_.Dispose()

        initiator_.Dispose()
        acceptor_.Dispose()
    End Sub

    ' Carries the sample out.
    Public Sub Run()
        ' Acceptor is being maintained manually.
        ' Therefore, reset of local sequence numbers
        ' must be done manually before logon.
        acceptor_.ResetLocalSequenceNumbers()

        ' Comment this call if you want to check
        ' how scheduler notifies about errors.
        acceptor_.LogonAsAcceptor()

        Dim scheduleForInitiator As SessionSchedule = ConstructShortTimeActivitySchedule()

        ' Let's play the party..

        scheduler_.Register(initiator_, scheduleForInitiator, New InitiatorConnectionSettings("localhost", 4500))

        Console.WriteLine("Session {0} scheduled for automatic connection.", initiator_)

        ' Since a session is initially in disconnected state,
        ' we can't simply wait for logout. Instead, we have
        ' to give time for a scheduler to activate the session.
        ' The best and simplest approach is to wait till time
        ' of logout, as it's specified in constructed schedule.

        PauseUntil(scheduleForInitiator.LogoutTimes(CInt(DateTime.Now.DayOfWeek)))

        ' Make sure that initiator is shutdown.
        WaitUntilLogout(initiator_)

        ' Don't forget that once initiator disconnects from
        ' the acceptor, the acceptor starts waiting for the next logon.
        ' Since we manage it manually, we have to call logout.

        acceptor_.Logout()
        WaitUntilLogout(acceptor_)
    End Sub

    ' Constructs schedule with a short time activity in 30 seconds.
    ' Also, logon time is delayed for a couple of seconds to demonstrate
    ' that scheduler will connect the session only when logon event occurs.
    Private Shared Function ConstructShortTimeActivitySchedule() As SessionSchedule
        Const logonDelayInSeconds As Integer = 5
        Const sessionDurationInSeconds As Integer = 30

        Dim logonTime As TimeSpan = DateTime.Now.TimeOfDay.Add(New TimeSpan(0, 0, logonDelayInSeconds))

        Dim logoutTime As TimeSpan = logonTime.Add(New TimeSpan(0, 0, sessionDurationInSeconds))

        Return New SessionSchedule(DayOfWeek.Sunday, DayOfWeek.Saturday, logonTime, logoutTime, SessionDuration.Day, SequenceNumberResetPolicy.Daily)
    End Function

    Private Shared Sub PauseUntil(ByVal timeOfDay As TimeSpan)
        System.Threading.Thread.Sleep(timeOfDay.Subtract(DateTime.Now.TimeOfDay))
    End Sub

    Private Shared Sub WaitUntilLogout(ByVal session__1 As Session)
        Const oneSecondPause As Integer = 1000

        While session__1.State <> Session.SessionState.DISCONNECTED
            System.Threading.Thread.Sleep(oneSecondPause)
        End While
    End Sub

End Class

Class Program
    Private Shared Sub Initialize()
        Const connectionPort As Integer = 4500

        Engine.Init(connectionPort)

        Engine.Instance.Settings.ReconnectAttempts = 2
        Engine.Instance.Settings.ReconnectInterval = 1
    End Sub

    Private Shared Sub CleanUp()
        If Engine.IsInitialized() Then
            Engine.Instance.Shutdown()
        End If
    End Sub

    Public Shared Sub Main(ByVal args As [String]())
        Try
            Initialize()

            Using sample As New Sample()
                sample.Run()
            End Using
        Catch ex As Exception
            Console.WriteLine()

            Console.WriteLine("Error while executing sample: {0}", ex)
        Finally
            CleanUp()
        End Try
    End Sub

End Class