Enum change listener

Indkabsling i en property kunne være tricket:

    class Program
    {
        static void Main(string[] args)
        {
            Commands();
        }

        private static Status m_status = Status.Slut;
        private static Status _status
        {
            get { return m_status; }
            set
            {
                // Hvis du skal btuge før-værdien ...
                Status _statusGl = m_status;
                Status _statusNy = value;

                // Udfør din ekstra kode her...
                // f.eks.:
                if (_statusNy != _statusGl)
                    Console.WriteLine("_status ændret");

                m_status = _statusNy;
            }
        }

        private static void Commands()
        {
            String cmd = Console.ReadLine().ToLower();

            if (cmd.Equals("start"))
                _status = Status.Start;

            if (cmd.Equals("slut"))
                _status = Status.Slut;

            Commands();
        }
    }

    enum Status
    {
        Start,
        Slut
    }

Det er sgu super det der :)

Koden ser sådan her ud nu :

class Program
    {
        private static Status m_status = Status.Slut;
        private static Status _status
        {
            get { return m_status; }
            set
            {
                m_status = value;
                OnStatusChange(m_status);
            }
        }

        private static void OnStatusChange(Status status)
        {
            switch (status)
            {
                case Status.Start:
                    Console.WriteLine("Du startede!");
                    break;
                case Status.Slut:
                    Console.WriteLine("Du sluttede");
                    break;
                default:
                    break;
            }
        }
        static void Main(string[] args)
        {
            Commands();
        }
        private static void Commands()
        {
            String cmd = Console.ReadLine().ToLower();
            if (cmd.Equals("start"))
                _status = Status.Start;
            if (cmd.Equals("slut"))
                _status = Status.Slut;
            if (cmd.Equals("exit") || cmd.Equals("quit"))
                return;
            Commands();
        }

       
    }
    enum Status { Start, Slut }

Værdien bliver ikke nødvendigvis ændret selv om ser() kaldes:

_status = Status.Start;
_status = Status.Start;
_status = Status.Start;

Vil du have at OnStatusChange() kaldes hver gang?

Det forstod jeg ikke lige ?

men for at den ikke skal køres hver gang kan man jo
private static Status _status
        {
            get { return m_status; }
            set
            {
                Status _statusOldValue = _status;
                m_status = value;
                if (_statusOldValue != value)
                    OnStatusChange(m_status);
            }
        }

Som du viste :)

men jeg så en kammerat i dag, han gjorde et eller andet fikst med en eventhandler, som gik ind og gjorde et eller andet som så også kørte koden når status'en blev lavet om

Hvordan kan det måske laves?

Der er ikke rigtigt noget der ringer.

Du må da meget geren poste det her, hvis du finder ud af det. :^)

Det skal jeg gøre :)

Ok, jeg tror at jeg ved hvad det gik ud på det der med EventHandler - jeg må tilstå at jeg nok blev lidt forvirret af at du brugte "OnStatusChanged" som normalt netop indikere at der er tale om en eventhandler - bortset fra at det ikke var en eventhandler i dit tilfælde.

Eventhandlere lægger normalt op til at man ønsker at kunen kommunikere f.eks. et status skift imellem to forskellige objekter. Enten af samme klasse, eller af forskellige klasser.

De ligger derimod ikke så meget op til at man bruger dem internt i samme instans, eller selve klasse (som når du bruger static på det hele). I det tilfælde er den kun med til at gøre syntaksen ugennemskuelig:

    // Prototypen for en eventhandler på Status.
    public delegate void StatusChanged(Status status);

    public enum Status { Start, Slut }

    class Program
    {
        // Eventhandlere giver normalt kun
        // mening, hvis de er synlige udefra.
        public static event StatusChanged OnStatusChanged;

        private static Status m_status = Status.Slut;
        internal static Status _status
        {
            get { return m_status; }
            set
            {
                m_status = value;

                // Hvis der er nogen som lytter, skal eventhandleren kaldes.
                if (OnStatusChanged != null)
                    OnStatusChanged(m_status);
            }
        }

        // Den metode som vi ønsker at kalde ved Status ændring.
        // Ved at indføre en eventhandler har vi besluttet os
        // for ikke at kalde den direkte fra set() metoden.
        private static void ChangeHasChanged(Status status)
        {
            switch (status)
            {
                case Status.Start:
                    Console.WriteLine("Du startede!");
                    break;
                case Status.Slut:
                    Console.WriteLine("Du sluttede");
                    break;
                default:
                    break;
            }
        }

        static void Main(string[] args)
        {
            // Set ChangeHasChanged til at lytte
            // på callbacks fra eventhandleren.
            OnStatusChanged = ChangeHasChanged;

            Commands();
        }

        private static void Commands()
        {
            String cmd = Console.ReadLine().ToLower();
            if (cmd.Equals("start"))
                _status = Status.Start;
            if (cmd.Equals("slut"))
                _status = Status.Slut;

            Commands();
        }
    }