EFlagsはこんな感じに

とりあえずアクセサメソッドはプロパティで

using System;

namespace vm.register
{
    public class EFlags
    {
        private Int32 eflags;

        public Int32 Value
        {
            set { this.eflags = value; }
            get { return eflags; }
        }

        public bool Carry
        {
            set
            {
                Int32 carryFlag = 0x01;

                if (value)
                {
                    eflags |= carryFlag;
                }
                else
                {
                    eflags &= ~carryFlag;
                }
            }

            get { return (eflags & 0x01) == 0x01; }
        }

        public bool Parity
        {
            set
            {
                Int32 parityFlag = 0x01 << 0x02;

                if (value)
                {
                    eflags |= parityFlag;
                }
                else
                {
                    eflags &= ~parityFlag;
                }
            }

            get {
                Int32 cparity = (eflags >> 0x02) & 0x01;
                return cparity == 0x01;
            }
        }

        public bool Adjust
        {
            set
            {
                Int32 adjustFlag = 1 << 0x04;

                if (value)
                {
                    eflags |= adjustFlag;
                }
                else
                {
                    eflags &= ~adjustFlag;
                }
            }

            get
            {
                Int32 cadjust = (eflags >> 0x04) & 0x01;
                return cadjust == 1;
            }
        }

        public bool Zero
        {
            set
            {
                Int32 zeroFlag = 0x01 << 0x06;

                if (value)
                {
                    eflags |= zeroFlag;
                }
                else
                {
                    eflags &= ~zeroFlag;
                }
            }

            get
            {
                Int32 czero = (eflags >> 0x06) & 0x01;
                return czero == 0x01;
            }
        }

        public bool Sign
        {
            set
            {
                Int32 signFlag = 1 << 0x07;

                if (value)
                {
                    eflags |= signFlag;
                }
                else
                {
                    eflags &= ~signFlag;
                }
            }

            get
            {
                Int32 csign = (eflags >> 0x07) & 0x01;
                return csign == 1;
            }
        }

        public bool Int32errupt
        {
            set
            {
                Int32 Int32erruptFlag = 1 << 0x09;

                if (value)
                {
                    eflags |= Int32erruptFlag;
                }
                else
                {
                    eflags &= ~Int32erruptFlag;
                }
            }

            get
            {
                Int32 cInt32errupt = (eflags >> 0x09) & 0x01;
                return cInt32errupt == 1;
            }
        }

        public bool Direction
        {
            set
            {
                Int32 directionFlag = 1 << 0x0A;

                if (value)
                {
                    eflags |= directionFlag;
                }
                else
                {
                    eflags &= ~directionFlag;
                }
            }

            get
            {
                Int32 cdirection = (eflags >> 0x0A) & 0x01;
                return cdirection == 1;
            }
        }

        public bool Overflow
        {
            set
            {
                Int32 overflowFlag = 1 << 0x0B;

                if (value)
                {
                    eflags |= overflowFlag;
                }
                else
                {
                    eflags &= ~overflowFlag;
                }
            
            }

            get
            {
                Int32 coverflow = (eflags >> 0x0B) & 0x01;
                return coverflow == 1;
            }
        }
    }
}