using System;

    /// <summary>
    ///     Stellt zweidimensionale Vektoren dar.
    /// </summary>
    ///
    /// <list type="table">
    ///     <listheader>
    ///         <description>Öffentliche Felder</description>
    ///     </listheader>
    ///     <item>
    ///         <term><see cref="X"/></term>
    ///         <description>X-Koordinate.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="Y"/></term>
    ///         <description>Y-Koordinate.</description>
    ///     </item>
    /// </list>
    /// <list type="table">
    ///     <listheader>
    ///         <description>Öffentliche Konstruktoren</description>
    ///     </listheader>
    ///     <item>
    ///         <term><see cref="Vector()"/></term>
    ///         <description>Überladen. Initialisiert einen neuen Vektor.</description>
    ///     </item>
    /// </list>
    /// <list type="table">
    ///     <listheader>
    ///         <description>Öffentliche Methoden</description>
    ///     </listheader>
    ///     <item>
    ///         <term><see cref="Add"/></term>
    ///         <description>Addiert den übergebenen Vektor zur aktuellen Instanz.</description>
    ///     </item>
    /// </list>
    /// <list type="table">
    ///     <listheader>
    ///         <description>Öffentliche Eigenschaften</description>
    ///     </listheader>
    ///     <item>
    ///         <term><see cref="Length"/></term>
    ///         <description>Gibt die Länge des Vektors an.</description>
    ///     </item>
    /// </list>
    /// <remarks>
    ///     <para>Die Objekte dieser Klasse repräsentieren zweidimensionale Vektoren. 
    ///           Beachten Sie, dass alle Rechenoperatoren direkt auf der aktuellen Instanz 
    ///           ausgeführt werden.</para>
    ///     <para>Der Funktionsumfang der Klasse ist derzeit noch sehr beschränkt, wird 
    ///           aber ausgebaut.</para>
    /// </remarks>
    /// <seealso cref="System.AnotherClass" />
    public class Vector
    {
        /// <summary>
        ///     X-Koordinate des Vektors.
        /// </summary>
        public int X;

        /// <summary>
        ///     Y-Koordinate des Vektors.
        /// </summary>
        public int Y;

        /// <summary>
        ///     Initialisiert eine neues <c>Vector</c>-Objekt. 
        /// </summary>
        /// <remarks>
        ///     Der Vektor weist auf den Ursprung (0,0).
        /// </remarks>
        public Vector()
        {
            X = 0;
            Y = 0;
        }

        /// <summary>
        ///     Initialisiert eine neues <c>Vector</c>-Objekt. 
        /// </summary>
        /// <param name="x">
        ///     Ein beliebiger <c>int</c>-Wert.
        /// </param>
        /// <param name="y">
        ///     Ein beliebiger <c>int</c>-Wert.
        /// </param>
        public Vector(int x, int y)
        {
            X = x;
            Y = y;
        }

        /// <summary>
        ///     Addiert den übergebenen Vektor zur aktuellen Instanz.
        /// </summary>
        /// <param name="v">
        ///     Vektor, der hinzuaddiert wird.
        /// </param>
        /// <returns>
        ///     Der alte Vektor.
        /// </returns>
        /// <exception cref="ArgumentNullException">
        ///     <c>v</c> ist NULL.
        /// </exception>    
        /// <remarks>
        ///     Beachten Sie, dass der übergebene Vektor zur aktuellen Instanz hinzuaddiert 
        ///     und der alte Vektor als Rückgabewert zurückgeliefert wird.
        /// </remarks>

        public Vector Add(Vector v)
        {
            Vector old = new Vector(this.X, this.Y);

            this.X += v.X;
            this.Y += v.Y;

            return old;
        }

        /// <summary>
        ///     Ruft die Länge des Vektors ab.
        /// </summary>
        /// <value>
        ///     Die Länge des Vektors.
        /// </value>
        /// <remarks>
        ///     Nur-Lesen-Eigenschaft.
        /// </remarks>
        public double Length
        {
            get
            {
                return Math.Sqrt(Math.Pow(this.X, 2) + Math.Pow(this.Y, 2));
            }
        }
    }


    class Program
    {
        static void Main()
        {
            Vector v1 = new Vector();
            Vector v2 = new Vector(10, 50);

            Vector old = v1.Add(v2);
            v2.Add(new Vector(-10, 25));

            Console.WriteLine(" old: ({0},{1}) - Laenge {2}", old.X, old.Y, old.Length);
            Console.WriteLine(" v1 : ({0},{1}) - Laenge {2}", v1.X, v1.Y, v1.Length);
            Console.WriteLine(" v2 : ({0},{1}) - Laenge {2}", v2.X, v2.Y, v2.Length);


        }
    }
