C# IUserInterface类代码示例

        private static void HandlePlayerTwoControls(IUserInterface keyboard, Engine engine)
        {
            keyboard.OnUpPressedPlayerTwo += (sender, eventInfo) =>
            {
                Console.SetCursorPosition(startRow, startCol);
                Console.WriteLine("Player2, make a move please!");
                engine.MovePlayerTwoUp();
            };

            keyboard.OnDownPressedPlayerTwo += (sender, eventInfo) =>
            {
                Console.SetCursorPosition(startRow, startCol);
                Console.WriteLine("Player2, make a move please!");
                engine.MovePlayerTwoDown();
            };

            keyboard.OnLeftPressedPlayerTwo += (sender, eventInfo) =>
            {
                Console.SetCursorPosition(startRow, startCol);
                Console.WriteLine("Player2, make a move please!");
                engine.MovePlayerTwoLeft();
            };

            keyboard.OnRightPressedPlayerTwo += (sender, eventInfo) =>
            {
                Console.SetCursorPosition(startRow, startCol);
                Console.WriteLine("Player2, make a move please!");
                engine.MovePlayerTwoRight();
            };
        }

        public void Display(IUserInterface userInterface, IServiceResult serviceResult)
        {
            if (userInterface == null)
            {
                throw new ArgumentNullException("userInterface");
            }

            if (serviceResult == null)
            {
                return;
            }

            if (serviceResult.Status == ServiceResultType.NoResult)
            {
                return;
            }

            if (string.IsNullOrWhiteSpace(serviceResult.Message))
            {
                return;
            }

            if (serviceResult.InnerResult != null)
            {
                this.Display(userInterface, serviceResult.InnerResult);
            }

            string resultTypeLabel = Resources.ServiceResultVisualizer.ResourceManager.GetString("ServiceResultType" + serviceResult.Status);
            userInterface.WriteLine(resultTypeLabel + ": " + serviceResult.Message);

            if (!string.IsNullOrWhiteSpace(serviceResult.ResultArtefact))
            {
                userInterface.WriteLine(Resources.ServiceResultVisualizer.ReturnValue + ": " + serviceResult.ResultArtefact);
            }
        }

        public Program(ApplicationInformation applicationInformation, IUserInterface userInterface, IActionLogger logger, ICommandLineArgumentInterpreter commandLineArgumentInterpreter, IHelpCommand helpCommand)
        {
            if (applicationInformation == null)
            {
                throw new ArgumentNullException("applicationInformation");
            }

            if (userInterface == null)
            {
                throw new ArgumentNullException("userInterface");
            }

            if (logger == null)
            {
                throw new ArgumentNullException("logger");
            }

            if (commandLineArgumentInterpreter == null)
            {
                throw new ArgumentNullException("commandLineArgumentInterpreter");
            }

            if (helpCommand == null)
            {
                throw new ArgumentNullException("helpCommand");
            }

            this.applicationInformation = applicationInformation;
            this.userInterface = userInterface;
            this.logger = logger;
            this.commandLineArgumentInterpreter = commandLineArgumentInterpreter;
            this.helpCommand = helpCommand;
        }

 public Store(IUserInterface userInterface)
 {
     this.userInterface = userInterface;
     this.myChashRegisterModule = new CashRegister(1.95583m, 1.53m);
     this.myStorageModule = new Storage();
     this.myStorageModule.LoadDB();
 }

        private static void ProcessKeyboardEvents(IUserInterface keyboard, ConsoleEngine engine)
        {
            keyboard.OnUpPressed += (sender, eventInfo) =>
            {
                engine.MovementManager.MovePlayerUp();
            };

            keyboard.OnDownPressed += (sender, eventInfo) =>
            {
                engine.MovementManager.MovePlayerDown();
            };

            keyboard.OnLeftPressed += (sender, eventInfo) =>
            {
                engine.MovementManager.MovePlayerLeft();
            };

            keyboard.OnUpLeftPressed += (sender, eventInfo) =>
            {
                engine.MovementManager.MovePlayerUpLeft();
            };

            keyboard.OnRightPressed += (sender, eventInfo) =>
            {
                engine.MovementManager.MovePlayerRight();
            };

            keyboard.OnUpRightPressed += (sender, eventInfo) =>
            {
                engine.MovementManager.MovePlayerUpRight();
            };
        }

		public void LoadViewStateConfiguration(IViewStateConfiguration viewStateConfiguration, IUserInterface userInterface)
		{
			this.ViewStateConfiguration = viewStateConfiguration;
			viewStates = viewStateConfiguration.ViewStateList;
			this._UI = userInterface;
			this.DefaultViewState = viewStateConfiguration.DefaultViewState;
		}

        private int stackPtr; //Pointer to next address to write to

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Creates a new z processor
        /// </summary>
        /// <param name="buf">memory buffer</param>
        /// <param name="ui">interface with the rest of the world</param>
        protected ZProcessor(MemoryBuffer buf, IUserInterface ui)
        {
            //Validate params
            if (buf == null)
            {
                throw new ArgumentNullException("buf");
            }
            else if (ui == null)
            {
                throw new ArgumentNullException("ui");
            }

            //Cache global vars offset
            globalVarsOffset = buf.GetUShort(0xC) - 0x10;

            //Globals vars must be higher than the header (security)
            if (globalVarsOffset + 0x10 < 64)
            {
                throw new ZMachineException("global variables table must not reside in the header");
            }

            //Set dynamic limit
            buf.DynamicLimit = Math.Min((int) buf.GetUShort(0xE), 64);

            //Store memory buffer and ui
            memBuf = buf;
            zUi = ui;

            //Create encoder and object tree
            zEncoder = new ZTextEncoder(buf);
            objectTree = new ZObjectTree(buf);
        }

        private static void HandlePlayerControls(IUserInterface keyboard, Engine engine)
        {
            keyboard.OnUpPressed += (sender, eventInfo) =>
            {
                engine.MoveCruiserUp();
            };

            keyboard.OnDownPressed += (sender, eventInfo) =>
            {
                engine.MoveCruiserDown();
            };

            keyboard.OnLeftPressed += (sender, eventInfo) =>
            {
                engine.MoveCruiserLeft();
            };

            keyboard.OnRightPressed += (sender, eventInfo) =>
            {
                engine.MoveCruiserRight();
            };

            keyboard.OnActionPressed += (sender, eventInfo) =>
            {
                engine.CruiserShoot();
            };
        }

 public Engine(PlayerType playerType, IUserInterface inputInterface)
 {
     this.PlayerType = playerType;
     this.rnd = new Random();
     this.inputInterface = inputInterface;
     this.AllObjects = new List<WorldObject>();
 }

        public VersionCheckerViewModel(VersionChecker versionChecker, FileDownloader fileDownloader,
            IUserInterface userInterface, IVersionCheckerConfig config, IVersionCheckerUserInterface versionCheckerUserInterface)
        {
            if (versionChecker == null) throw new ArgumentNullException("versionChecker");
            if (fileDownloader == null) throw new ArgumentNullException("fileDownloader");
            if (userInterface == null) throw new ArgumentNullException("userInterface");
            if (config == null) throw new ArgumentNullException("config");
            if (versionCheckerUserInterface == null) throw new ArgumentNullException("versionCheckerUserInterface");

            this.versionChecker = versionChecker;
            this.fileDownloader = fileDownloader;
            this.userInterface = userInterface;
            this.config = config;
            this.versionCheckerUserInterface = versionCheckerUserInterface;

            CheckAgainCommand = new RelayCommand(p => true, CheckAgainClicked);
            DownloadCommand = new RelayCommand(p => true, DownloadClicked);
            OpenDownloadedFileCommand = new RelayCommand(p => true, OpenDownloadedFileClicked);
            CheckAtStartupCommand = new RelayCommand(p => true, CheckAtStartupChanged);
            CloseCommand = new RelayCommand(p => true, CloseClicked);

            ChangeStateToEmpty();

            versionChecker.CheckStarting += HandleVersionCheckStarting;
            versionChecker.CheckCompleted += HandleCheckCompleted;

            this.fileDownloader.DownloadFileStarting += HandleDownloadFileStarting;
            this.fileDownloader.DownloadProgressChanged += HandleDownloadProgressChanged;
            this.fileDownloader.DownloadFileCompleted += HandleDownloadFileCompleted;

            config.CheckAtStartUpChanged += HandleOptionsCheckAtStartupChanged;

            CheckAtStartupEnabled = true;
            CheckAtStartupValue = config.CheckAtStartUp;
        }

        public SelfUpdateService(IUserInterface userInterface, ApplicationInformation applicationInformation, IPackageRepositoryBrowser packageRepositoryBrowser, IFilesystemAccessor filesystemAccessor)
        {
            if (userInterface == null)
            {
                throw new ArgumentNullException("userInterface");
            }

            if (applicationInformation == null)
            {
                throw new ArgumentNullException("applicationInformation");
            }

            if (packageRepositoryBrowser == null)
            {
                throw new ArgumentNullException("packageRepositoryBrowser");
            }

            if (filesystemAccessor == null)
            {
                throw new ArgumentNullException("filesystemAccessor");
            }

            this.userInterface = userInterface;
            this.applicationInformation = applicationInformation;
            this.packageRepositoryBrowser = packageRepositoryBrowser;
            this.filesystemAccessor = filesystemAccessor;
        }

 private Engine(CommandExecuter executor, IUserInterface userIo)
 {
     this.executor = executor;
     this.userIO = userIo;
     //// DI: Added IUserInterface and ConsoleIo types
     //// and made the constructor take an user interface usin DI
 }

 public ConsoleEngine(IUserInterface userInterface, int sleepTime)
 {
     this.userInterface = userInterface;
     this.SleepTime = sleepTime;
     this.MovementManager = new MovementManager();
     CurrentLevel = OutsideLevel.AboveGround;
     Player = new Mario(new MatrixCoordinates(Console.WindowHeight - 7, 0), MarioImages.RightProfile);
 }

        private readonly IUserInterface userInterface; // the user control on the console via keyboard.

        #endregion Fields

        #region Constructors

        // constructor - creates an on object of the Engine type
        public Engine(IRenderer renderer, IUserInterface userInterface)
        {
            this.renderer = renderer;
            this.userInterface = userInterface;
            this.AllObjects = new List<WorldObject>();
            this.MovingObjects = new List<MovableObject>();
            this.StaticObjects = new List<StaticObject>();
        }

 public void SetView(IUserInterface userinterface)
 {
     foreach (IUser user in users)
     {
         user.SetView(userinterface);
     }
     invalidUser.SetView(userinterface);
 }