C Exception macros

/***********************************************************************\
* Exception handling. *
\***********************************************************************/

#include

typedef struct EXCEPTION
{
jmp_buf stack;
} Exception;

typedef enum STATE
{
Success,
Warning,
Error,
Fatal
} State;

extern Exception gs_x_env;
extern State gs_x_state;
extern void* gs_x_exception;
extern Bool gs_x_flag;

#define TRY \
{ \
static Exception l_x_env; \
gs_x_flag=False; \
gs_x_exception=0; \
l_x_env=gs_x_env; \
if (setjmp(gs_x_env.stack)==0) \
{

#define CATCH(a_type,a_var) \
gs_x_flag=False; \
} \
else \
{ \
a_type a_var; \
gs_x_env=l_x_env; \
a_var=(a_type)gs_x_exception; \
(void)a_var;

#define FINALLY \
gs_x_flag=False; \
} \
gs_x_env=l_x_env; \
}

#define RAISE \
{ \
if (gs_x_flag) \
{ \
longjmp(gs_x_env.stack,1); \
} \
} \
(void)0

#define THROW(a_state,a_var) \
{ \
gs_x_flag=True; \
gs_x_state=a_state; \
gs_x_exception=(void*)a_var; \
RAISE; \
} \
(void)0

#define isSuccess (gs_x_state==Success)
#define isFailure (gs_x_state!=Success)
#define isWarning (gs_x_state==Warning)
#define isError (gs_x_state==Error)
#define isFatal (gs_x_state==Fatal)

LINQ Samples

I copied all the LINQ samples to a personal project.

https://www.amazon.com/clouddrive#G=0&path=/Documents

Singleton

How to unit test a Singleton pattern?

using System;

public sealed class Singleton
{
   private static volatile Singleton instance;
   private static object syncRoot = new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null) 
         {
            lock (syncRoot) 
            {
               if (instance == null) 
                  instance = new Singleton();
            }
         }

         return instance;
      }
   }
}

Answer: Don't use a Singleton. Use Dependency Injection.

TDD

I am trying out some TDD on Mat Buckland’s AI example code from “Programming AI by Example”. I translated Telegram.h to Telegram.css:

// -----------------------------------------------------------------------
// Telegram.cs
// -----------------------------------------------------------------------

namespace WestWorld
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

    /// <summary>
    /// TODO: Update summary.
    /// </summary>
    public class Telegram
    {
        /// <summary>
        /// These telegrams will be stored in a priority queue. Therefore the >
        /// operator needs to be overloaded so that the PQ can sort the telegrams
        /// by time priority. Note how the times must be smaller than
        /// SmallestDelay apart before two Telegrams are considered unique.
        /// </summary>
        private const double SmallestDelay = 0.25;

        /// <summary>
        /// the entity that sent this telegram
        /// </summary>
        private int sender;

        /// <summary>
        /// the entity that is to receive this telegram
        /// </summary>
        private int receiver;
        
        /// <summary>
        /// the message itself. These are all enumerated in the file "MessageTypes.h"
        /// </summary>
        private int msg;

        /// <summary>
        /// Messages can be dispatched immediately or delayed for a specified amount
        /// of time. If a delay is necessary this field is stamped with the time 
        /// the message should be dispatched.
        /// </summary>
        private double dispatchTime;

        // any additional information that may accompany the message
//        void*        ExtraInfo;

        /// <summary>
        /// Initializes a new instance of the <see cref="Telegram"/> class.
        /// </summary>
        public Telegram()
        {
            this.sender = 0;
            this.receiver = 0;
            this.msg = 0;
            this.dispatchTime = 0;
        }

        /// <summary>
        /// Gets or sets the sender.
        /// </summary>
        /// <value>
        /// The sender.
        /// </value>
        public int Sender
        {
            get { return this.sender; }
            set { this.sender = value; }
        }

        /// <summary>
        /// Gets or sets the receiver.
        /// </summary>
        /// <value>
        /// The receiver.
        /// </value>
        public int Receiver
        {
            get { return this.receiver; }
            set { this.receiver = value; }
        }

        /// <summary>
        /// Gets or sets the message.
        /// </summary>
        /// <value>
        /// The message.
        /// </value>
        public int Message
        {
            get { return this.msg; }
            set { this.msg = value; }
        }

        /// <summary>
        /// Gets or sets the dispatch time.
        /// </summary>
        /// <value>
        /// The dispatch time.
        /// </value>
        public double DispatchTime
        {
            get { return this.dispatchTime; }
            set { this.dispatchTime = value; }
        }

        /// <summary>
        /// Implements the operator ==.
        /// </summary>
        /// <param name="t1">The t1.</param>
        /// <param name="t2">The t2.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        public static bool operator ==(Telegram t1, Telegram t2)
        {
            double temp = Math.Abs(t1.DispatchTime - t2.DispatchTime);

            return Math.Abs(t1.DispatchTime - t2.DispatchTime) < Telegram.SmallestDelay && 
                t1.DispatchTime == t2.DispatchTime;
        }

        /// <summary>
        /// Implements the operator !=.
        /// </summary>
        /// <param name="t1">The t1.</param>
        /// <param name="t2">The t2.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        public static bool operator !=(Telegram t1, Telegram t2)
        {
            return Math.Abs(t1.DispatchTime - t2.DispatchTime) > Telegram.SmallestDelay && 
                t1.DispatchTime != t2.DispatchTime;
        }

        /// <summary>
        /// Implements the operator &lt;.
        /// </summary>
        /// <param name="t1">The t1.</param>
        /// <param name="t2">The t2.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        public static bool operator <(Telegram t1, Telegram t2)
        {
            if (t1 == t2)
            {
                return false;
            }
            else
            {
                return t1.DispatchTime < t2.DispatchTime;
            }
        }

        /// <summary>
        /// Implements the operator &gt;.
        /// </summary>
        /// <param name="t1">The t1.</param>
        /// <param name="t2">The t2.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        public static bool operator >(Telegram t1, Telegram t2)
        {
            if (t1 == t2)
            {
                return false;
            }
            else
            {
                return t1.DispatchTime > t2.DispatchTime;
            }
        }

        /// <summary>
        /// Determines whether the specified <see cref="System.Object"/> is equal to this instance.
        /// </summary>
        /// <param name="obj">The <see cref="System.Object"/> to compare with this instance.</param>
        /// <returns>
        ///   <c>true</c> if the specified <see cref="System.Object"/> is equal to this instance; otherwise, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            return (Telegram)obj == this;
        }

        /// <summary>
        /// Returns a hash code for this instance.
        /// </summary>
        /// <returns>
        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
        /// </returns>
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}

The test class is TestTelegram.cs:

namespace TestWestWorld
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using Microsoft.VisualStudio.TestTools.UnitTesting;

    using WestWorld;

    /// <summary>
    /// Tests for the Telegram class
    /// </summary>
    [TestClass]
    public class TestTelegram
    {
        /// <summary>
        /// Test context
        /// </summary>
        private TestContext testContextInstance;

        /// <summary>
        /// Initializes a new instance of the <see cref="TestTelegram"/> class.
        /// </summary>
        public TestTelegram()
        {
            // TODO: Add constructor logic here
        }

        /// <summary>
        /// Gets or sets the test context which provides
        /// information about and functionality for the current test run.
        /// </summary>
        public TestContext TestContext
        {
            get
            {
                return this.testContextInstance;
            }

            set
            {
                this.testContextInstance = value;
            }
        }

        #region Additional test attributes

        // You can use the following additional attributes as you write your tests:

        // Use ClassInitialize to run code before running the first test in the class
        // [ClassInitialize()]
        // public static void MyClassInitialize(TestContext testContext) { }

        // Use ClassCleanup to run code after all tests in a class have run
        // [ClassCleanup()]
        // public static void MyClassCleanup() { }

        // Use TestInitialize to run code before running each test 
        // [TestInitialize()]
        // public void MyTestInitialize() { }

        // Use TestCleanup to run code after each test has run
        // [TestCleanup()]
        // public void MyTestCleanup() { }
        #endregion

        /// <summary>
        /// Tests the telegram equals == operator
        /// </summary>
        [TestMethod]
        public void TestTelegramEqualsOperator()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            Assert.IsTrue(telegram1 == telegram2);
        }

        /// <summary>
        /// Tests the telegram not equals operator.
        /// </summary>
        [TestMethod]
        public void TestTelegramNotEqualsOperator()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            Assert.IsFalse(telegram1 != telegram2);
        }

        /// <summary>
        /// Tests the telegram equals method.
        /// </summary>
        [TestMethod]
        public void TestTelegramEqualsMethod()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            Assert.IsTrue(telegram1.Equals(telegram2));
        }

        /// <summary>
        /// Tests the telegram not equals method.
        /// </summary>
        [TestMethod]
        public void TestTelegramNotEqualsMethod()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            telegram1.DispatchTime = 25;
            Assert.IsFalse(telegram1.Equals(telegram2));
        }

        /// <summary>
        /// Tests the telegram not equals operator when the object members
        /// have been set to different values.
        /// </summary>
        [TestMethod]
        public void TestTelegramEqualsOperatorWhenObjectNotSame()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            telegram1.DispatchTime = 25;
            Assert.IsFalse(telegram1 == telegram2);
        }

        /// <summary>
        /// Tests the telegram not equals operator when the object members
        /// have been set to different values.
        /// </summary>
        [TestMethod]
        public void TestTelegramNotEqualsOperatorWhenObjectNotSame()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            telegram1.DispatchTime = 25;
            Assert.IsTrue(telegram1 != telegram2);
        }

        /// <summary>
        /// Tests the telegram less than operator when the object members
        /// have been set to different values.
        /// </summary>
        [TestMethod]
        public void TestTelegramLessThanOperatorWhenObjectIsSame()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            Assert.IsFalse(telegram1 < telegram2);
        }

        /// <summary>
        /// Tests the telegram less than operator when the object members
        /// have been set to different values.
        /// </summary>
        [TestMethod]
        public void TestTelegramLessThanOperatorWhenObjectIsNotSame()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            telegram1.DispatchTime = 25;
            Assert.IsFalse(telegram1 < telegram2);
        }

        /// <summary>
        /// Tests the telegram less than operator when the object members
        /// have been set to different values.
        /// </summary>
        [TestMethod]
        public void TestTelegramLessThanOperatorWhenObjectNotSameButLess()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            telegram2.DispatchTime = 25;
            Assert.IsTrue(telegram1 < telegram2);
        }

        /// <summary>
        /// Tests the telegram greater than operator when the object members
        /// have been set to different values.
        /// </summary>
        [TestMethod]
        public void TestTelegramGreaterThanOperatorWhenObjectIsSame()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            Assert.IsFalse(telegram1 > telegram2);
        }

        /// <summary>
        /// Tests the telegram greater than operator when the object members
        /// have been set to different values.
        /// </summary>
        [TestMethod]
        public void TestTelegramGreaterThanOperatorWhenObjectIsNotSame()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            telegram1.DispatchTime = 25;
            Assert.IsFalse(telegram1 < telegram2);
        }

        /// <summary>
        /// Tests the telegram greater than operator when the object members
        /// have been set to different values.
        /// </summary>
        [TestMethod]
        public void TestTelegramGreaterThanOperatorWhenObjectNotSameButLess()
        {
            Telegram telegram1 = new Telegram();
            Telegram telegram2 = new Telegram();

            telegram2.DispatchTime = 25;
            Assert.IsTrue(telegram1 < telegram2);
        }
    }
}

When getting data to a DataGrid in VS 2010, don't set the AutoGenerateColumns to 'true' and then add your own columns. You get double columns.

So now what?

From MSDN:

Command-line compilation can be used to build applications with more complexity, although the compiler does not support WPF applications that include Extensible Application Markup Language (XAML) source code. Furthermore, command-line compilation does not support the full range of build requirements of typical WPF applications, including configuration management and ClickOnce manifest generation. To support these and other more complex build requirements, WPF integrates with and extends MSBuild.

You can't use the command line to compile XAML applications. Why?

NAnt and .NET 3.5

From an old entry by Jeffrey Palermo:

Unfortunately, we don't have a .Net 3.5-compatible NAnt distribution
yet, but it's trivial to get the latest version (.85) working with
.Net 3.5 and a Visual Studio 2008 solution.  Open up you nant.exe
config file, and add the following framework node just below your net-2.0 node.  Not much of a change, and it's working well for me.

<framework name="net-3.5"
    family="net"
    version="3.5"
    description="Microsoft .NET Framework 3.5"
    runtimeengine=""
    sdkdirectory="${path::combine(sdkInstallRoot, 'bin')}"
    frameworkdirectory="${path::combine(installRoot, 'v3.5')}"
    frameworkassemblydirectory="${path::combine(installRoot, 'v2.0.50727')}"
    clrversion="2.0.50727">

    <task-assemblies>
        <!-- include .NET specific assemblies -->
    <include name="tasks/net/*.dll" />
    <!-- include .NET 2.0 specific assemblies -->
    <include name="tasks/net/2.0/**/*.dll" />
    <!-- include Microsoft.NET specific task assembly -->
    <include name="NAnt.MSNetTasks.dll" />
    <!-- include Microsoft.NET specific test assembly -->
    <include name="NAnt.MSNet.Tests.dll" />
    </task-assemblies>

  <project>
        <readregistry property="installRoot"
            key="SOFTWARE\Microsoft\.NETFramework\InstallRoot"
            hive="LocalMachine" />

    <readregistry property="sdkInstallRoot"
            key="SOFTWARE\Microsoft\.NETFramework\sdkInstallRootv2.0"
            hive="LocalMachine"
            failonerror="false" />
    </project>

  <tasks>
        <task name="csc">
            <attribute name="exename">csc</attribute>
      <attribute name="supportsnowarnlist">true</attribute>
      <attribute name="supportswarnaserrorlist">true</attribute>
      <attribute name="supportskeycontainer">true</attribute>
      <attribute name="supportskeyfile">true</attribute>
      <attribute name="supportsplatform">true</attribute>
      <attribute name="supportslangversion">true</attribute>
      </task>

      <task name="vbc">
      <attribute name="exename">vbc</attribute>
      <attribute name="supportsdocgeneration">true</attribute>
      <attribute name="supportsnostdlib">true</attribute>
      <attribute name="supportsnowarnlist">true</attribute>
      <attribute name="supportskeycontainer">true</attribute>
      <attribute name="supportskeyfile">true</attribute>
      <attribute name="supportsplatform">true</attribute>
      <attribute name="supportswarnaserrorlist">true</attribute>
      </task>

      <task name="jsc">
      <attribute name="exename">jsc</attribute>
      <attribute name="supportsplatform">true</attribute>
      </task>

      <task name="vjc">
      <attribute name="exename">vjc</attribute>
      <attribute name="supportsnowarnlist">true</attribute>
      <attribute name="supportskeycontainer">true</attribute>
      <attribute name="supportskeyfile">true</attribute>
      </task>

      <task name="resgen">
      <attribute name="exename">resgen</attribute>
      <attribute name="supportsassemblyreferences">true</attribute>
      <attribute name="supportsexternalfilereferences">true</attribute>
      </task>

      <task name="al">
      <attribute name="exename">al</attribute>
      </task>

      <task name="delay-sign">
      <attribute name="exename">sn</attribute>
      </task>

      <task name="license">
      <attribute name="exename">lc</attribute>
      <attribute name="supportsassemblyreferences">true</attribute>
      </task>

      <task name="ilasm">
      <attribute name="exename">ilasm</attribute>
      </task>

      <task name="ildasm">
      <attribute name="exename">ildasm</attribute>
      </task>
    </tasks>
</framework>

Next, change the following in your NAnt build:

<property name="nant.settings.currentframework" value="net-3.5" />