1.  C – The type of the parent object.

2.  O<P> – A collection of instances of P. This is a hybrid collection-dictionary that allows end users to retrieve instances by index or by a key. The implementation extends KeyedCollection<K,V>.

3.  P – The type of the instances in O<P>. Instances of P have to maintain a Parent relationship with the instance of C that “contains” them. They also have a Name property which assigns each instance of P a string name that is unique in its parent container (an instance of O<P>).

While the rest of the behavior is up to the user, we will focus on

1. What should happen when the Name or Parent of an instance of P changes.
2. What should happen when an instance of P is added or removed from the O<P> container in an instance of C.

In this particular specification and implementation, only one instance of an instance of P exists in an instance of O<P> and further, instances are accessed in O(1) time by using the Name property as a key.

Nor surprisingly, because of the entities involved, I call it the Parent-Container-Child pattern. Of course, I have seen similar patterns, for example in LINQ but I haven’t seen this pattern expressed in a generic form anywhere. Please feel free to post links or resources about similar or the same pattern that is discussed better or implemented better in the comments. While it is possible to implement this with internal functions, state variables etc, here are some restrictions that we will impose that makes the problem less of a hack and more applicable generally:

1. No internal functions. We will only use advertised interfaces and/or public functions. Further, we will not use special functions that could be misused.
2. No state variables. We do not want to do hacky things such as keeping a state variable to communicate between event handlers etc.

Interestingly, imposing these restrictions leads to a cleaner design than not imposing them. In fact, my first approach did involve using hacky public functions (that could be misused easily) and state variables to signal that some event handler should not handle a particular event because it was indirectly raised due to an action made by another event handler. This state variable was required to ensure that there was no circular chain of events.

Now, let’s come up with a free format, simple to read technical specification for the above problem.

C

Contains Properties collection of instances of P.

P

Parent Property

When Parent is changed

a. If old parent and new parent are same instance, no effect.

b. Signal that parent is going to be changed.

c. Signal to the new parent that it is becoming the parent of a new child.

d. Set new parent.

e. Signal that parent has been changed.

f. Signal to the new parent that it has become the parent of a new child.

Name Property

When Name is changed

a. If new value of Name is invalid, throw exception.

b. If new value of Name and current Name are the same, no effect.

c. Signal that the name is going to be changed.

d. Set new name.

e. Signal that the name has been changed.

O<P>

General Operations

a. When an object is added to the collection:

1. If its name is incorrect, throw an exception.

2. If its name already exists, thrown an exception.

3. Signal that an object is going to be added.

4. Add the object.

5. Signal that an object has been added.

6. Subscribe to name change events on the object.

b. When an object is removed from the collection:

1. If its name is incorrect, throw an exception.

2. If its name already exists, throw an exception.

3. Signal that an object is going to be removed.

4. Unsubscribe from name change events on the object.

5. Remove the object.

6. Signal that an object has been removed.

c. When the collection is cleared:

1. Signal that the collection is clearing.

2. Unsubscribe from name changes for each object.

3. Signal that the collection has been cleared.

Name Changes

OnNameChanging

1. Check that the new name does not already exist.

OnNameChanged

1. Change the name of the object.

Expectations

No circular event handling leading to death by a stack overflow.

Parent is Changed

oldParent.Properties.Contains(p) = false

newParent.Properties.Contains(p) = true

p.Parent = newParent

oldParent does not receive events from p.

newParent receives events from p.

Name is Changed

parent.Properties.Contains(oldName) = false

parent.Properties.Contains(newName) = true

parent.Properties[newName] = p

Based on these specifications, we can figure out the scenarios we will need to test:

In the following,

• c, c1 and c2 are instances of C.
• p is an instance of P.

1. When an unnamed instance p is added to c.Properties, an exception should be thrown.
2. When a named but un-parented instance p is added to c.Properties, then
   • The p should acquire c as its Parent.
   • c.Properties must have an entry for p.Name.
   • c.Properties[p.Name] should be equal to p.
3. For an existing named instance p in c.Properties, when p.Name is changed, then
   • p.Parent must still be c.
   • c.Properties must not have an entry for p’ old name.
   • c.Properties must have an entry for p.Name.
   • c.Properties[p.Name] must be p.
4. When an existing named instance p in c.Properties is removed, then
   • p.Parent must be null.
   • c.Properties must not have an entry for p.Name
5. For an existing named instance p in c1.Properties, when p.Parent is changed to c2, then
   • p.Parent must be c2.
   • c1.Properties must not contain p.
   • c2.Properties must container p.
6. For an existing instance p in c1.Properties, when p is added to c2.Properties, then
   • p.Parent must be c2.
   • c1.Properties should not contain p.
   • c2.Properties should contain p. 

The complete source code that demonstrates an implementation of the above pattern is provided in this file. (You will need VSTT 2008 to run the tests). The solution divides the responsibilities of maintaining the relationships correctly amongst C, P and O<P>. Further, for the solution to be correct according to the tests we have outlined, we the order in which actions are performed and the time at which they are performed are important.

P

Implementation of the type P is rather simple.

When its Name property is changed and the new value is valid and different from its old value, then an event NameChanging is fired before the change is fired and an event NameChanged is fired after the change is persisted.

When its Parent property is changed and the new value is different from its old value, then an event ParentChanging is fired before the change is persisted and an event ParentChanged is fired after the change is persisted. The following code fragment shows how this is implemented:

The responsibility of the type P ends here. Thus, its task in the PCC pattern is to ensure that the appropriate checks are carried out and that the appropriate events are fired to notify the parent and the container that some aspect of it is changing.

O<P>

Implementing O<P> is fairly simple. In the sample implementation, O<P> is named ObservableKeyedCollection<TKey, TValue> and extends the KeyedCollection<K,V> type. The responsibilities of the O<P> type in the PCC pattern include:

1. Notify the parent when an item is added or removed or when the collection is cleared.
2. Listen to Name change events raised by the child instances and update the associated entry for that item.
3. When an item is added to the collection: fire the ItemAdding event before adding the item and fire the ItemAdded event after adding the item; subscribe to name change events on the item.
4. When an item is removed from the collection, fire the ItemRemoving event before removing the item and fire the ItemRemoved event after removing the item; unsubscribe from name change events on the item.

All of these are simple to implement and the following code fragments show how these are implemented in the sample:

C

The parent type C has the responsibility for maintaining the Parent relationship with instances of type P. The following code fragments illustrates how this is implemented in the sample:

AutoParentChild_Final.zip

    /// <summary>
    /// A enumeration of all possible partitions of a set of items.
    /// </summary>
    /// <typeparam name="T">The type of the items in the set being partitioned.</typeparam>
    public sealed class AllPartitionsEnumerable<T> : IEnumerable<IEnumerable<IEnumerable<T>>>
    {
        /// <summary></summary>
        [DebuggerBrowsable(DebuggerBrowsableState.Collapsed)]
        private IEnumerable<T> items;

        /// <summary>
        /// Creates and initializes an instance of the <see cref="AllPartitionsEnumerable{T}"/> type.
        /// </summary>
        /// <param name="items">The set of items to be partitioned.</param>
        public AllPartitionsEnumerable(IEnumerable<T> items)
            : base ()
        {
            this.items = items;
        }

        /// <summary>
        /// Gets an enumerator to iterate over the partitions in this enumeration.
        /// </summary>
        /// <returns>An instance of <see cref="IEnumerator{T}"/>.</returns>
        public IEnumerator<IEnumerable<IEnumerable<T>>> GetEnumerator()
        {
            return new AllPartitionsEnumerator<T>(this.items);
        }

        /// <summary>
        /// Gets an enumerator to iterate over the partitions in this enumeration.
        /// </summary>
        /// <returns>An instance of <see cref="IEnumerator{T}"/>.</returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
    }

    /// <summary>
    /// An enumerator to iterate over the items in an instance of <see cref="AllPartitionsEnumerable{T}"/>.
    /// </summary>
    /// <typeparam name="T">The type of the items in the set being partitioned.</typeparam>
    public sealed class AllPartitionsEnumerator<T> : IEnumerator<IEnumerable<IEnumerable<T>>>
    {
        /// <summary>The original set of items over which partitions are created.</summary>
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private T[] items;

        /// <summary>Flag to indicate if this enumerator has been disposed of.</summary>
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private bool isDisposed;

        /// <summary>Flag to indicate if this enumerator is in its initial state.</summary>
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private bool isFirst;

        /// <summary>The number of partitions in the current selection.</summary>
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private int nc;

        /// <summary>An array of values indicating the number of values in the partition at the specified index.</summary>
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private int[] p;

        /// <summary>An array of indices indicating to which partition the item at the specified index belongs.</summary>
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private int[] q;

        /// <summary>The current partition.</summary>
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private T[][] current;

        /// <summary>
        /// Creates and initializes an instance of the <see cref="AllPartitionsEnumerator{T}"/> type.
        /// </summary>
        /// <param name="items">The original set of items over which partitions are enumerated.</param>
        public AllPartitionsEnumerator(IEnumerable<T> items)
            : base()
        {
            if (null == items)
            {
                throw new ArgumentNullException("items");
            }

            this.isFirst = true;
            this.items = items.ToArray();
            this.nc = 0;
            this.p = new int[this.items.Length];
            this.q = new int[this.items.Length];
            this.current = null;
        }

        /// <summary>
        /// Gets the current partition.
        /// </summary>
        public IEnumerable<IEnumerable<T>> Current
        {
            get
            {
                this.CheckIfDisposed();

                return this.current;
            }
        }

        /// <summary>
        /// Disposes of this enumerator and releases all resources held by it.
        /// </summary>
        public void Dispose()
        {
            if (this.isDisposed)
            {
                return;
            }

            this.isDisposed = true;
            this.items = null;
            this.p = null;
            this.q = null;
            this.nc = 0;
            this.current = null;
            this.isFirst = true;
        }

        /// <summary>
        /// Gets the current partition.
        /// </summary>
        object IEnumerator.Current
        {
            get
            {
                return this.Current;
            }
        }

        /// <summary>
        /// Selects the next item in the set of all partitions.
        /// </summary>
        /// <returns><c>true</c> if an item was selected; <c>false</c> if we are past the last element.</returns>
        public bool MoveNext()
        {
            this.CheckIfDisposed();

            if (this.isFirst)
            {
                this.isFirst = false;
                this.nc = 1;
                this.p[0] = this.items.Length;
                for (int i = 0; i < this.items.Length; ++i)
                {
                    this.q[i] = this.nc;
                }
                this.Select();
                return true;
            }

            if (this.nc == this.items.Length )
            {
                return false;
            }

            int n = this.items.Length;
            int m = n;
            int l = this.q[m-1];

            while (this.p[l - 1] == 1)
            {
                this.q[m - 1] = 1;
                --m;
                l = this.q[m - 1];
            }

            this.nc += m - n;
            this.p[0] = this.p[0] + n - m;

            if (l == this.nc)
            {
                ++this.nc;
                this.p[this.nc - 1] = 0;
            }

            this.q[m - 1] = l + 1;
            this.p[l - 1] = this.p[l - 1] - 1;
            this.p[l] = this.p[l] + 1;

            this.Select();
            return true;
        }

        /// <summary>
        /// Resets this enumerator to its initial state.
        /// </summary>
        public void Reset()
        {
            this.CheckIfDisposed();

            this.current = null;
            this.isFirst = true;
            this.isDisposed = false;
            this.p = new int[this.items.Length];
            this.q = new int[this.items.Length];
            this.nc = 0;
        }

        /// <summary>
        /// Selects the items for the current partition.
        /// </summary>
        private void Select()
        {
            this.current = new T[this.nc][];

            for (int i = 0; i < this.nc; ++i)
            {
                int k = 0;
                this.current[i] = new T[this.p[i]];

                for (int j = 0; j < this.items.Length; ++j)
                {
                    if (this.q[j] == i + 1)
                    {
                        this.current[i][k] = this.items[j];
                        ++k;
                    }
                }
            }
        }

        /// <summary>
        /// Checks and throws an exception if this enumerator has been disposed.
        /// </summary>
        private void CheckIfDisposed()
        {
            if (this.isDisposed)
            {
                throw new ObjectDisposedException(this.GetType().FullName);
            }
        }
    }

        /// <summary>
        /// Retrieves all possible partitions of a set of items.
        /// </summary>
        /// <typeparam name="T">The type of the items in the original set.</typeparam>
        /// <param name="items">The original set of items over which partitions are created.</param>
        /// <returns>All possible partitions of the items in <paramref name="items"/>.</returns>
        public static IEnumerable<IEnumerable<IEnumerable<T>>> AllPartitions<T>(this IEnumerable<T> items)
        {
            return new AllPartitionsEnumerable<T>(items);
        }

That’s all there is to it. A simple program that generates the 52 partitions of the set {1, 2, 3, 4, 5} is given below:

            var intset = 1.To(5);
            var parts = intset.AllPartitions();

            int j = 1;
            foreach (var part in parts)
            {
                var list = part.ToList();

                Console.Write((j++) + " - ");
                Console.Write(list[0].ToCsvString());

                for (int i = 1; i < list.Count; ++i)
                {
                    Console.Write(" : ");
                    Console.Write(list[i].ToCsvString());
                }

                Console.WriteLine();
            }

Have fun.

Please note: I hope to make the two implementations posted here as well a few others related to simple combinatorial objects available as an open source library on CodePlex

. I will post details when this is done.

The following F95 program generates all partitions of a set.

SUBROUTINE NEXEQU(N, NC, P, Q, MTC)

INTEGER, DIMENSION(N) :: P

INTEGER, DIMENSION(N) :: Q

LOGICAL MTC

    IF(MTC) GOTO 20

10  NC=1

    DO 11 I=1,N

11  Q(I)=1

    P(1)=N

60  MTC=NC .NE. N

    RETURN

20  M=N

30  L=Q(M)

    IF(P(L) .NE. 1) GOTO 40

    Q(M)=1

    M=M-1

    GOTO 30

40  NC=NC+M-N

    P(1)=P(1)+N-m

    IF(L .NE. NC) GOTO 50

    NC=NC+1

    P(NC)=0

50  Q(M)=L+1

    P(L)=P(L)-1

    P(L+1)=P(L+1)+1

    GOTO 60

END 

The following is a test program for the above sub-routine.

SUBROUTINE TESTNEXEQU

    INTEGER, DIMENSION(5) :: P

    INTEGER, DIMENSION(5) :: Q

    LOGICAL MTC

    INTEGER L

    INTEGER NC

    L = 1

    DO 10 I = 1, 5

        P(I) = 0

        Q(I) = 0

10  CONTINUE

    MTC = .FALSE.

20  CONTINUE

        CALL NEXEQU (5, NC, P, Q, MTC)

        WRITE(*,"(I2)", advance="no") L

        WRITE(*,"(A)", advance="no") " - "

        DO 40 J = 1, NC

            DO 30 I = 1, 5

                IF (Q(I) .EQ. J) WRITE (*,"(I2), ",advance="no") I        

30          CONTINUE

            WRITE(*,"(A)", advance="no") " , "

40      CONTINUE

    PRINT *

    L = L+1

    IF (MTC) GOTO 20

END

A C# implementation of the above algorithm will be published soon.

THe above code is made available in the hope that it will be useful. Microsoft (my employer) neither endorses nor gaurantees nor assumes any liability for this code. Neither do I.

    /// <summary>

    /// An enumeration of all the permuations of a set of items.

    /// </summary>

    /// <typeparam name="T"></typeparam>

    public class AllPermutationsEnumerable<T> : IEnumerable<IEnumerable<T>>

    {

        /// <summary>The set of items over which all permutations are generated.</summary>

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]

        private IEnumerable<T> items;

        /// <summary>

        /// Creates and initializes a new instance of the <see cref="AllPermutationsEnumerable{T}"/> type.

        /// </summary>

        /// <param name="items">The original set of items over which all permutations are generated.</param>

        public AllPermutationsEnumerable(IEnumerable<T> items)

            : base()

        {

            this.items = items;

        }

        /// <summary>

        /// Gets an enumerator to enumerate over the items in this enumeration.

        /// </summary>

        /// <returns>An instance of <see cref="IEnumerator{T}"/>.</returns>

        public IEnumerator<IEnumerable<T>> GetEnumerator()

        {

            return new AllPermutationsEnumerator<T>(this.items);

        }

        /// <summary>

        /// Gets an enumerator to enumerate over the items in this enumeration.

        /// </summary>

        /// <returns>An instance of <see cref="IEnumerator{T}"/>.</returns>

        IEnumerator IEnumerable.GetEnumerator()

        {

            return new AllPermutationsEnumerator<T>(this.items);

        }

    }

 The enumerator is implemented as follows:

    /// <summary>

    /// Enumerators over all possible permutations of a set of items.

    /// </summary>

    /// <typeparam name="T">The type of the items in the original set.</typeparam>

    public class AllPermutationsEnumerator<T> : IEnumerator<IEnumerable<T>>

    {

        /// <summary>The set of items over which all permutations are generated.</summary>

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]

        private T[] originalItems;

        /// <summary>Flag to indicate if this enumerator is in its initial state.</summary>

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]

        private bool isFirst;

        /// <summary>Flag to indicate if this enumerator has been disposed of.</summary>

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]

        private bool isDisposed;

        /// <summary>The current permutation.</summary>

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]

        private T[] current;

        /// <summary>The indicates of the items in the original set that are selected for the current permutation.</summary>

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]

        private int[] indices;

        /// <summary>A state variable used by the permutation algorithm.</summary>

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]

        private bool even;

        /// <summary>A state variable used by the permutation algorithm to track whether this enumerator is finished.</summary>

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]

        private bool isFinished;

        /// <summary>

        /// Creates and initializes an instance of the <see cref="AllPermutationsEnumerator{T}"/> type.

        /// </summary>

        /// <param name="items">The set of items over which permutations are to be created.</param>

        public AllPermutationsEnumerator(IEnumerable<T> items)

            : base()

        {

            if (null == items)

            {

                throw new ArgumentNullException("items");

            }

            this.originalItems = items.ToArray();

            this.indices = new int[this.originalItems.Length];

            for (int i = 0; i < this.indices.Length; ++i)

            {

                this.indices[i] = i + 1;

            }

            this.current = null;

            this.even = true;

            this.isDisposed = false;

            this.isFirst = true;

            this.isFinished = false;

        }

        /// <summary>

        /// Gets the current item referred to by this enumerator.

        /// </summary>

        public IEnumerable<T> Current

        {

            get

            {

                this.CheckIfDisposed();

                return this.current;

            }

        }

        /// <summary>

        /// Disposes of this enumerator.

        /// </summary>

        public void Dispose()

        {

            if (this.isDisposed)

            {

                return;

            }

            this.isDisposed = true;

            this.originalItems = null;

            this.current = null;

            this.indices = null;

            this.even = true;

            this.isFirst = true;

            this.isFinished = false;

        }

        /// <summary>

        /// Gets the current item referred to by this enumerator.

        /// </summary>

        object IEnumerator.Current

        {

            get

            {

                return this.Current;

            }

        }

        /// <summary>

        /// Moves this enumerator to refer to the next item in the enumeration.

        /// </summary>

        /// <returns><c>true</c> if a value is available; <c>false</c> if the end has been reached.</returns>

        public bool MoveNext()

        {

            this.CheckIfDisposed();

            if (this.isFinished)

            {

                return false;

            }

            if (this.isFirst)

            {

                this.even = true;

                this.isFirst = false;

                this.Select();

                return true;

            }

            else if (this.originalItems.Length == 1)

            {

                this.current = null;

                return false;

            }

            if (even)

            {

                this.even = false;

                this.indices.Swap(0, 1);

                this.Select();

                if (!((this.indices[this.indices.Length-1] != 1) || (this.indices[0] != (2 + this.indices.Length % 2))))

                {

                    if (this.indices.Length <= 3)

                    {

                        this.isFinished = true;

                    }

                    else

                    {

                        this.isFinished = true;

                        for (int i = 0 ; i < (this.indices.Length - 3); ++i)

                        {

                            if (this.indices[i+1] != this.indices[i]+1)

                            {

                                this.isFinished = false;

                            }

                        }

                    }

                }

                return true;

            }

            int s = 0;

            this.even = true;

            for (int k = 1; k < this.indices.Length; ++k)

            {

                int d = 0;

                int ia = this.indices[k];

                int i = k - 1;

                for (int j = 0; j <= i; ++j)

                {

                    if (this.indices[j] > ia)

                    {

                        ++d;

                    }

                }

                s += d;

                if (d != (i+1) * (s % 2))

                {

                    int l = 0;

                    int m = ((s + 1) % 2) * (this.indices.Length + 1);

                    for (int j = 0; j <= i; ++j)

                    {

                        if (this.Sign(1, this.indices[j] - ia) != this.Sign(1, this.indices[j] - m))

                        {

                            m = this.indices[j];

                            l = j;

                        }

                    }

                    this.indices[l] = ia;

                    this.indices[k] = m;

                    this.even = true;

                    this.Select();

                    break;

                }

            }

            return true;

        }

        /// <summary>

        /// Simulates the fortran SIGN function that computes the absolute of the parameter <paramref name="x"/>

        /// and then assigns the sign of the parameter <paramref name="y"/> to <paramref name="x"/> and returns

        /// this new value.

        /// </summary>

        /// <param name="x">The value to sign.</param>

        /// <param name="y">The value that determines the sign.</param>

        /// <returns><paramref name="x"/> signed by <paramref name="y"/>.</returns>

        private int Sign(int x, int y)

        {

            if (y >= 0)

            {

                x = Math.Abs(x);

            }

            else

            {

                x = -1 * Math.Abs(x);

            }

            return x;

        }

        /// <summary>

        /// Selects the items in the current permutation based on the computed indicies of the items

        /// to be selected.

        /// </summary>

        private void Select()

        {

            this.current = new T[this.originalItems.Length];

            for (int i = 0; i < this.indices.Length; ++i)

            {

                this.current[i] = this.originalItems[this.indices[i] - 1];

            }

        }

        /// <summary>

        /// Resets this enumerator to the initial state.

        /// </summary>

        public void Reset()

        {

            this.CheckIfDisposed();

            for (int i = 0; i < this.indices.Length; ++i)

            {

                this.indices[i] = i + 1;

            }

            this.current = null;

            this.even = true;

            this.isDisposed = false;

            this.isFirst = true;

            this.isFinished = false;

        }

        /// <summary>

        /// Checks and throws an exception if this enumerator has been disposed.

        /// </summary>

        private void CheckIfDisposed()

        {

            if (this.isDisposed)

            {

                throw new ObjectDisposedException(this.GetType().FullName);

            }

        }

    }

Granted, that is probably no thte cleanest or the best implementation, but hey, it does the job. And of course, an extension method to make this available to any enumeration:

        /// <summary>

        /// Retrieves all possible permutations of a set of items.

        /// </summary>

        /// <typeparam name="T">The type of the items in the original set.</typeparam>

        /// <param name="items">The original set of items over which permutations are created.</param>

        /// <returns>All permutations of the items in <paramref name="items"/>.</returns>

        public static IEnumerable<IEnumerable<T>> AllPermutations<T>(this IEnumerable<T> items)

        {

            return new AllPermutationsEnumerable<T>(items);

        }

The only problem with the above code is that it does not take care of permutations of sets with repetitions.

THe above code is made available in the hope that it will be useful. Microsoft (my employer) neither endorses nor gaurantees nor assumes any liability for this code. Neither do I.

SUBROUTINE NEXPER(N, A, MTC, EVEN)
INTEGER N
INTEGER, DIMENSION(N) :: A
INTEGER S, D, NM3, IA, I1, L
LOGICAL MTC, EVEN
    IF (MTC) GOTO 10
    NM3 = N-3
    DO 1 I=1,N
1   A(I)=I
    MTC=.TRUE.
5   EVEN=.TRUE.
    IF(N .EQ. 1) GOTO 8
6   IF(A(N) .NE. 1 .OR. A(1) .NE. 2+MOD(N,2)) RETURN
    IF(N .LE. 3) GOTO 8
    DO 7 I=1,NM3
    IF(A(I+1) .NE. A(I)+1) RETURN
7   CONTINUE
8   MTC=.FALSE.
    RETURN
10  IF(N .EQ. 1) GOTO 27
    IF(.NOT. EVEN) GOTO 20
    IA=A(1)
    A(1)=A(2)
    A(2)=IA
    EVEN=.FALSE.
    GOTO 6
20  S=0
    DO 26 I1=2,N
25  IA=A(I1)
    I=I1-1
    D=0
    DO 30 J=1,I
30  IF(A(J) .GT. IA) D=D+1
    S=D+S
    IF(D .NE. I*MOD(S,2)) GOTO 35
26  CONTINUE
27  A(1)=0
    GOTO 8
35  M=MOD(S+1,2)*(N+1)
    DO 40 J=1,I
    IF(ISIGN(1,A(J)-IA) .EQ. ISIGN(1,A(J)-M)) GOTO 40
    M=A(J)
    L=J
40  CONTINUE
    A(L)=IA
    A(I1)=M
    EVEN=.TRUE.
    RETURN
END

SUBROUTINE TESTNEXPER
    INTEGER, DIMENSION(5) :: IN
    LOGICAL MTC
    LOGICAL EVEN
    DO 10 I = 1, 5
    IN(I) = I
10  CONTINUE
    MTC = .FALSE.
20  CONTINUE
    CALL NEXPER (5, IN, MTC, EVEN)
    DO 30 I = 1, 5
        WRITE (*,"(I2), ",advance="no") IN(I)
30  CONTINUE
    PRINT *
    IF (MTC) GOTO 20
END


I can use WS-Discovery and I know how to do this with the .NET 4.0 Discovery API. However, the only sample I could find is multicast, which in my use case is not sufficient because:-

1. I already know which machines may be hosting the service.
2. UDP multicast is going to be unreliable given that I have potentially many machines on the network, but I am targetting only a limited subset.
3. Managed mode with a proxy is not going to work either, because this is yet another "pre-requisite" I have to setup.

This should be easy right? Startup, send a message to one or more machines and wait for a specified period of time for a reply.

For some reason, however, that doesn't suffice. Any ideas?

ProcessStartInfo psi = new ProcessStartInfo();

		    psi.Arguments = this.CreateArgumentsString();

		    psi.FileName = this.ImageFile;

		    psi.CreateNoWindow = true;

		    psi.RedirectStandardError = true;

		    psi.RedirectStandardInput = true;

		    psi.RedirectStandardOutput = true;

		    psi.WorkingDirectory = this.WorkingDirectory;

		    psi.UseShellExecute = false;

		    Process p = new Process();

		    p.OutputDataReceived += new DataReceivedEventHandler(ProcessOutputDataReceived);

		    p.ErrorDataReceived += new DataReceivedEventHandler(ProcessErrorDataReceived);

		    p.StartInfo = psi;

		    p.EnableRaisingEvents = true;

p.Start();

p.BeginErrorReadLine();

		    p.BeginOutputReadLine();

		    p.WaitForExit();

That will redirect output and error data from your child process to the console asynchronously (er, depending on the implementation of ProcessOutputDataReceived and ProcessErrorDataReceived). Which is good because if the invoking application is a console application and you want to see the output/error in real time then you want it to work like this.

But, I don't have any recursive or other code that could cause a stack overflow. So what could be the problem? Apparently, when you have implicit function evaluation is enabled in VS (Tools -> Options -> Debugging) and the evaluated function/property has a recursion (type?) this could happen. Another reason it could happen is if you have the "DebuggerDisplay" attribute on your type. I do this often because I would like to glance at the instance and get an idea of what it is. Maybe this is the problem? It is in fact the problem.

As I implemented these changes, I used LINQ from the beginning. But, recently an issue arose when I was testing reporting with multiple parallel test agents. The problem was that the entries for the same entity inserted twice. This would break analysis and so I created a unique index key on the columns that uniquely identify an entity. I set the IGNORE_DUP_KEY option on this index as well. Unfortunately, LINQ can't handle this. LINQ won't gracefully handle a duplicate insert.

On a side note, to handle this, I create a stored procedure to perform the check and insert within a serializable transaction and invoked this via LINQ. However, again, when going at it with multiple test agents, this approach breaks down because the database server kills one of the transaction as a deadlock victim. This will be propagated as a SqlException with an error code of 1209 which you may want to handle if you want to retry the submit after some random interval.

Pre Requisites

I copied over the MyTest folder in the Visual Studio SDK to a separate directory. In doing so, I discovered some issues with the MyTestUI project. You will have to open up the MyTestUI.vcproj file in NotePad and replace the "..\..\..\..\VisualStudioIntegration\" parts with PATHTOVSSDK\VisualStudioIntegration. This ensures that the copied over solution builds correctly.

Another point to note is that I moved the entire solution to a location with no spaces in the path. That way I don't have deal with all the long name related issues. (As a matter of principle, I usually never put anything except the default stuff in locations with spaces in the name.)

A third action is to go through the registry searching for anything with a "MyTest*" entry and deleting them. This ensures that we are starting with a clean slate.

Finally, open up MyTest.sln. Fix your solution configuration. MyTestUI.vcproj is a VC project targeting Win32 and MyTest.csproj is a C# project targeting AnyCPU. Make sure your solution has only one configuration that builds the (Debug, Release) configurations with the Win32 and AnyCPU platforms for these projects respectively.

OK. Now open up MyTest.sln and rebuild everything. Open a VS command shell (in your Start menu folder for Visual Studio 2008, there is a Visual Studio Tools folder). Navigate to the location you copied the MyTest sample to and execute deploy.bat Debug. That should succeed.

Then execute devenv /setup. This ensures that your project and item templates are rebuilt. Start up Visual Studio, create a test project. Then add a new test item and voila! you should see MyTest and a MyTest Wizard entry in the test types dialog.

More on what happens after you select the MyTest test in the next post.