Modellieren, Dokumentieren und Testen mit dem VS2005

Heute hab ich mir mal die für mich neuen Features des Visual Studio 2005 etwas näher angesehen.

Modellieren

Das Visual Studio 2005 besitzt nun einen recht netten Klassen-Designer mit dem Entwickler Typen visuell erstellen und bearbeiten können.
Änderungen im Quelltext werden sofort im Klassendiagramm ersichtlich und umgekehrt, auch Refectoring funktioniert direkt im Klassendiagramm.

Mehr zum Klassen-Designer von Visual Studio 2005 findet sich z.B. im Visual C# 2005 <openbook> von Galileo Computing.

Dokumentieren

Um den Quellcode zu dokumentieren stehen unter Visual Studio 2005 die sogenannten XML-Kommentare zur Verfügung, sie fungieren ähnlich wie JavaDoc, nur halt auf Basis von XML.
Auf diese Weise können Typen wie Klassen, Enumerationen, Delegate, Schnittstellen und Strukturen sowie deren Eigenschaften, Felder, Methoden, Ereignisse usw. beschrieben werden.

using System;
using System.Collections;

namespace TestDrivenStackSample
{
    /// <summary>
    /// Represents a simple last-in-first-out (LIFO) non-generic 
    /// collection of <see cref="System.Object">Objects</see>.
    /// </summary>
    /// <example>
    /// <code>
    /// using System;
    /// using System.Collections;
    ///
    /// public class StackSample
    /// {
    ///     public static void PrintValues(IEnumerable collection, char separator)
    ///     {
    ///         foreach (Object obj in collection)
    ///         {
    ///             Console.Write("{0}{1}", separator, obj);
    ///         }
    ///
    ///         Console.WriteLine();
    ///     }
    ///
    ///     static void Main(string[] args)
    ///     {
    ///         // Creates and initializes a new Stack.
    ///         Stack stack = new Stack();
    ///         stack.Push("The");
    ///         stack.Push("quick");
    ///         stack.Push("brown");
    ///         stack.Push("fox");
    ///
    ///         // Displays the Stack.
    ///         Console.Write("Stack values:");
    ///         PrintValues(stack, '\t');
    ///
    ///         // Removes an element from the Stack.
    ///         Console.WriteLine("(Pop)\t\t{0}", stack.Pop());
    ///
    ///         // Displays the Stack.
    ///         Console.Write("Stack values:");
    ///         PrintValues(stack, '\t');
    ///
    ///         // Removes another element from the Stack.
    ///         Console.WriteLine("(Pop)\t\t{0}", stack.Pop());
    ///
    ///         // Displays the Stack.
    ///         Console.Write("Stack values:");
    ///         PrintValues(stack, '\t');
    ///
    ///         // Views the first element in the Stack but does not remove it.
    ///         Console.WriteLine("(Top)\t\t{0}", stack.Top());
    ///
    ///         // Displays the Stack.
    ///         Console.Write("Stack values:");
    ///         PrintValues(stack, '\t');
    ///     }
    /// }
    /// 
    /// /* 
    /// This code produces the following output.
    /// 
    /// Stack values:   fox     brown   quick   The
    /// (Pop)           fox
    /// Stack values:   brown   quick   The
    /// (Pop)           brown
    /// Stack values:   quick   The
    /// (Top)           quick
    /// Stack values:   quick   The
    /// */
    /// </code>
    /// </example>
    public class Stack : IEnumerable
    {
        private ArrayList elements = new ArrayList();
        
        /// <summary>
        /// Gets a value indicating whether the 
        /// <see cref="TestDrivenStackSample.Stack">Stack</see> is empty.
        /// </summary>
        /// <value>
        /// <c>true</c>, if the <see cref="TestDrivenStackSample.Stack">
        /// Stack</see> is empty; otherwise, <c>false</c>.
        /// </value>
        public bool IsEmpty
        {
            get { return (elements.Count == 0); }
        }

/// <summary>
        /// Inserts an <see cref="System.Object">Object</see> at the top 
        /// of the <see cref="TestDrivenStackSample.Stack">Stack</see>.
        /// </summary>
        /// <param name="element">
        /// The <see cref="System.Object">Object</see> to push onto 
        /// the <see cref="TestDrivenStackSample.Stack">Stack</see>.
        /// </param>
        public void Push(Object element)
        {
            elements.Insert(0, element);
        }

/// <summary>
        /// Removes and returns the <see cref="System.Object">Object</see> at 
        /// the top of the <see cref="TestDrivenStackSample.Stack">Stack</see>.
        /// </summary>
        /// <returns>
        /// The <see cref="System.Object">Object</see> removed from the top of 
        /// the <see cref="TestDrivenStackSample.Stack">Stack</see>.
        /// </returns>
        /// <exception cref="System.InvalidOperationException">
        /// Thrown when the <see cref="TestDrivenStackSample.Stack">Stack</see> 
        /// is empty.
        /// </exception>
        public Object Pop()
        {
            Object top = Top();
            elements.RemoveAt(0);
            return top;
        }

/// <summary>
        /// Returns the <see cref="System.Object">Object</see> at the top of the 
        /// <see cref="TestDrivenStackSample.Stack">Stack</see> without removing it.
        /// </summary>
        /// <returns>
        /// The <see cref="System.Object">Object</see> at the top of the 
        /// <see cref="TestDrivenStackSample.Stack">Stack</see>.
        /// </returns>
        /// <exception cref="System.InvalidOperationException">
        /// Thrown when the <see cref="TestDrivenStackSample.Stack">Stack</see> 
        /// is empty.
        /// </exception>
        public Object Top()
        {
            if (IsEmpty)
            {
                throw new InvalidOperationException("Stack is Empty");
            }

return elements[0];
        }

/// <summary>
        /// Returns an <see cref="System.Collections.IEnumerator">IEnumerator
        /// </see> for the <see cref="TestDrivenStackSample.Stack">Stack</see>.
        /// </summary>
        /// <returns>
        /// An <see cref="System.Collections.IEnumerator">IEnumerator</see> 
        /// for the <see cref="TestDrivenStackSample.Stack">Stack</see>.
        /// </returns>
        public IEnumerator GetEnumerator()
        {
            foreach (Object element in elements)
            {
                yield return element;
            }
        }
    }
}

Visual Studio 2005 kann selber leider keine HTML-Hilfe-Datei aus den XML-Kommentaren erzeugen, benutzt die dokumentierten Kommentare aber zur Anzeige in IntelliSense und im Objektbrowser.
Zum Erzeugen einer HTML-Hilfe-Datei steht allerdings das freie Tool NDoc zur Verfügung, jedoch unterstützt dieses zur Zeit noch nicht .NET 2.0, es gibt aber ein inoffizielles Release von Jonas Lagerblad.

Mehr zum Dokumentieren des Quellcodes mittels XML-Kommentaren findet man ebenfalls im Visual C# 2005 <openbook> von Galileo Computing.

Testen

Zur Testgetriebenen Softwareentwicklung mit dem Visual Studio 2005 gibts zum Beispiel das csUnit-Plugin, das sich nahtlos in die IDE-Umgebung des Visual Studio 2005 integriert.

So, das waren nun kurz die Erfahrungen die ich heute bzw. gestern mit dem Visual Studio 2005 gesammelt habe.

posted on Thursday, July 20, 2006 12:20 PM

dast.blog();

News

Google dast.blog();

Archives

Post Categories

Image Galleries

Artikel

CodeProject Artikel

Homepage

Links

PocketPCDN Artikel