namespace ingutiliidid
{
    // Muutujad
    // http://msdn.microsoft.com/en-us/library/1dhd7f2x.aspx
    // Threading
    // http://www.albahari.com/threading/part2.html
    using System;

    /// <summary>
    ///
    /// Summary description for Class1
    /// Üldiselt Ingmar õpib siin natuke;
    /// </summary>
    /// Namespace loogiline grupeerimine
    ///
    // http://www.albahari.com/threading/part2.html
    /*
    http://msdn.microsoft.com/en-us/library/sf985hc5(VS.80).aspx
    abstract class learnNetAbstract
    {
       // tavaline abstraktne meetod; delphis lubatud tavalises classis
       // Imelik, et need abstraktsed meetodid peavad olema abstraktses klassis
       public  abstract void annaOPsys();        
    }
   // -------------------------------------
     * // huvitav asi on SEALED class
      sealed class SedaPolevoimalikEdasiAnd
      {
       }
     
    
    */
    public class learnNet
    {
        private string FTootajanimi;
        private int Fmingiarve;
        // -------------------------------------
        //static List<string> list = new List<string>();
        // defineerime eelinitsialiseeritud muutuja
        public const string EelDefineeritudNimi = "INGMAR";
        // !!!huvitav tüüp readonly, st. seda muutujat saab initsialiseerida vaid constructori osas
        public static readonly string teeInit;
        // -------------------------------------
        public string TootajaNimi
        {
            get
            {
                return FTootajanimi;
            }

            set
            {
                // value sissetulev väärtus
                FTootajanimi = value;
            }

        }

        // normaalne constructor

        public learnNet()
        {
            /*
            XmlDocument myXmlDocument = new XmlDocument();
            myXmlDocument.Load(filename);
            XmlTextReader reader = new XmlTextReader(filename);
            XmlDocument doc = new XmlDocument();
            */


        }

        // overloaded
        public learnNet(int mingiarv)
        {
            // see constructor võib teha midagi arvuga :))
            this.Fmingiarve = mingiarv;
        }

        // Staatiline constructor on suht naljakas asi minu jaoks
        // Aga ta ei tohi sisaldada sisendparameetrid
        // Aga siin saab readonly muutujatele init teha !!
        static learnNet()
        {
            teeInit = "Omapärane RO feature";
        }

        // -------------------------------------
        // tüüpiline virtuaalne meetod
        // -------------------------------------

        public virtual void meetodKinni()
        {
            // meetod kinni
        }

        public virtual void teeMidagiHuvitavat()
        {
            Console.WriteLine("Teeks midagi huvitavat klassis !" + GetType().ToString()); // this.GetType

            // Console.WriteLine("derived.GetType returns {0}", derived.GetType());

        }


        // -------------------------------------
        // staatiline proc
        // -------------------------------------
        public static int vastusXxX(int x, int x2)
        {
            Console.WriteLine("vastusXxX 1 käivitati");
            return (int)x * x2;
        }

        // tavaline overload
        public static double vastusXxX(double x, int x2)
        {
            return (double)x * x2;
        }

        // -------------------------------------


    }

    public class learnNetExt : learnNet
    {
        /*
        Sama ka klassidega
          internal class BaseClass
         {
              public static int intM = 0;
         }
         */
        // ainult sama assembly sees nähtav 
        protected internal int huvitavaNahtavusegaMuutuja;

        protected void naguDelphiVar(ref int minginumber)
        {
            minginumber = 123456;
        }

        /*
         * http://msdn.microsoft.com/en-us/library/x13ttww7.aspx
         * Integral types such as sbyte, byte, short, ushort, int, uint, char, float, and bool.
         * Huvitav deklaratsioon volatile, sisuliselt threadsafe klassisisene muutuja
        */

        public uint ainultSuurenda;



        // -----------------
        public sealed override void meetodKinni()
        {
            Console.WriteLine("Virtuaalne meetod kinni !");
        }

        // anname abstraktsele protseduurile keha
        public void annaOPsys()
        {

            OperatingSystem os = Environment.OSVersion;
            PlatformID pid = os.Platform;
            switch (pid)
            {
                case PlatformID.Win32NT:
                    {
                        Console.WriteLine("WinNT");
                        break;
                    }
                case PlatformID.Win32S:
                    {
                        Console.WriteLine("Win32S");
                        break;
                    }
                case PlatformID.Win32Windows:
                    {
                        Console.WriteLine("Win32");
                        break;
                    }
                case PlatformID.WinCE:
                    {
                        Console.WriteLine("WinCE");
                        break;
                    }
                case PlatformID.Unix:
                    {
                        Console.WriteLine("Unix");
                        break;
                    }
                default:
                    {
                        Console.WriteLine("Tundmatu opSys");
                        break;
                    }
            }
        }


        public override void teeMidagiHuvitavat()
        {
            base.teeMidagiHuvitavat(); // sama, mis delphis INHERITED !
            Console.WriteLine("Teeks midagi huvitavat uues klassis !" + GetType().ToString()); // this.GetType           
            // mõned asjalikud funktsioonid
            this.annaOPsys();
        }


        // Üks lahe feature, piiratute parameetrite arvuga protseduur !!!!!!!!
        public void naguArrayOfConstDelphis(params object[] list)
        {
            for (int i = 0; i < list.Length; i++)
            {
                Console.WriteLine(list[i] + " ");
            }
            Console.WriteLine();
        }

        public void valjastaMingiNumber()
        {
            int muutuja = 654321;
            this.naguDelphiVar(ref muutuja);
            Console.WriteLine(muutuja);
        }
       
    }
}

/*

test1.cs:
using System;

class ComplexNumber
{
  public int Real;
  public int Imaginary;

  public ComplexNumber(int real, int imaginary) {
    this.Real = real;
    this.Imaginary = imaginary;
  }

  public static ComplexNumber operator +(ComplexNumber a, ComplexNumber b) {
    return new ComplexNumber(a.Real + b.Real, a.Imaginary + b.Imaginary);
  }

  public static ComplexNumber operator -(ComplexNumber a, ComplexNumber b) {
    return new ComplexNumber(a.Real - b.Real, a.Imaginary - b.Imaginary);
  }

  public override string ToString() {
    if (this.Imaginary > 0)
      return (string.Format("{0} + {1}i", this.Real, this.Imaginary));
    else
      return (string.Format("{0} - {1}i", this.Real, Math.Abs(this.Imaginary)));
  }
}


public class MainClass
{
  public static void Main() {
    ComplexNumber a = new ComplexNumber(2, 5);
    ComplexNumber b = new ComplexNumber(4, -3);
    Console.WriteLine(string.Format("a = ({0}), b = ({1})", a, b));
    Console.WriteLine(string.Format("a + b = ({0})", a + b));
    Console.WriteLine(string.Format("a - b = ({0})", a - b));
  }
}
*/