Month: October 2003

In order to provide sorting capabilities
for me Session List custom control, I needed a way to sort the ArrayList that I am
using to store my data.  Within
the .Net Compact Framework it is possible to due this by implementing the IComparable
interface on the object class I’m storing in the array. This allows a single sort
method. To provide multiple ways to sort the data, I can add more flexibility allowing
multiple sort orders by implementing IComparer. The code listed below allows me to
easily add the desired sort without adding a lot of custom sort code and taking advantage
of the framework.

 

 

Public Class SessionListItem

        Implements IComparable

 

.

.  ‘
The rest of the class code is here

.

 

        Public Function CompareTo(ByVal obj As Object) As Integer _

        Implements IComparable.CompareTo

            ‘
The default sort method

            Return Me.SessionCode.CompareTo(CType(obj,
SessionListItem).SessionCode)

        End Function

 

        Public Shared ReadOnly Property SortByName() As IComparer

            Get

                Return CType(New SortByNameClass,
IComparer)

            End Get

        End Property

 

        Public Shared ReadOnly Property SortByTitle() As IComparer

            Get

                Return CType(New SortByTitleClass,
IComparer)

            End Get

        End Property

 

        Public Class SortByNameClass

            Implements IComparer

 

            Public Function Compare(ByVal obj1 As Object, ByVal obj2 As Object) As Integer Implements IComparer.Compare

                ‘SortByName
can use the default IComparable interface

                ‘
so call the CompareTo method

                Return CType(obj1,
IComparable).CompareTo(CType(obj2, SessionListItem))

            End Function    ‘Compare

        End Class    ‘SortByNameClass

        Public Class SortByTitleClass

            Implements IComparer

            Public Function Compare(ByVal obj1 As Object, ByVal obj2 As Object) As Integer Implements IComparer.Compare

                ‘SortByTitle
compares the integer property

                Dim SessionListItem1 As SessionListItem
= CType(obj1, SessionListItem)

                Return SessionListItem1.m_SessionTitle.CompareTo(CType(obj2,
SessionListItem).m_SessionTitle)

            End Function    ‘Compare

        End Class    ‘SortByTitleClass

    End Class

 

 

 

A full day it has been! Tonight at the Triangle .Net
User Group I enjoyed a very entertaining talk on the “Benefits of Exploration
Testing” presented by Justin Gehtland founding partner of Relevance,
LLC. Justin shared a learn by doing approach to software development. His highlights
include:

 

The key principles that motivate Exploration Testing are:

 

1. *The best documentation is observed
behavior.* Instead of reading

about how something should work, make
it work yourself.

2. *Failures in your application are
your fault, even if they aren’t

in your code.*Between system libraries,
frameworks, and third

party tools, most of “your” code isn’t
actually /your /code.

However, this is little consolation
to users who trusted /you/ to

assemble a correctly functioning application.

3. *Learning is active.* Passively
reading text or listening to an

instructor does not provide adequate
reinforcement of concepts.

4. *Programmers* *are often forced
to choose technologies based on

incomplete information.* Basing major
decisions on documentation

alone is certain to lead to suffering
later.

5. *Programmers must isolate and work
around bugs in supporting

libraries.* Since the technologies
are chosen based on incomplete

information, we are often forced to
work around shortcomings or

flaws in the chosen technology.

6. *Knowledge must be kept continuously
up-to-date. *Writing some

sample code before using an API in
a shipping application is a

very good idea, but it isn’t enough.
Your knowledge of an API needs

to be validated against every patch
or upgrade that end users

might encounter. Exploration testing
naturally dovetails with

continuous integration.

 

He’s got a white paper and
some other really good info on his site! I think with the pace of change in the industry,
the succesful learning styles are changing. They need to for us to keep up!