C# IMemento类代码示例

 public IAggregate Build(Type type, Guid id, IMemento snapshot)
 {
     //if (type == typeof(IMyInterface))
     //    return new MyAggregate();
     //else
         return Activator.CreateInstance(type) as IAggregate;
 }

 void IOrginator.SetMemento(IMemento memento)
 {
     var bankCardMemento = (BankCardMemento)memento;
     Id = bankCardMemento.Id;
     _accountId = bankCardMemento.AccountId;
     _disabled = bankCardMemento.Disabled;
 }

 /// <summary>
 /// Initializes a new instance of the CommandContext class.
 /// </summary>
 /// <param name="game">Command context's IGame.</param>
 /// <param name="scoreboard">Command context'sIScoreboard.</param>
 /// <param name="boardHistory">Command context's IMemento.</param>
 public CommandContext(IGame game, IScoreboard scoreboard, IMemento boardHistory)
 {
     this.Game = game;
     this.ScoreboardInfo = scoreboard;
     this.BoardHistory = boardHistory;
     this.Moves = 0;
 }

		public IAggregate Build(Type type, Guid id, IMemento snapshot)
		{
			ConstructorInfo constructor = type.GetConstructor(
				BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(Guid) }, null);

			return constructor.Invoke(new object[] { id }) as IAggregate;
		}

        public IAggregate Build(Type type, Guid id, IMemento snapshot)
        {
            var types = snapshot == null ? new[] { typeof(Guid) } : new[] { typeof(Guid), typeof(IMemento) };
            var args = snapshot == null ? new object[] { id } : new object[] { id, snapshot };

            ConstructorInfo constructor = type.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, types, null);

            return constructor.Invoke(args) as IAggregate;
        }

        protected override void SetMemento(IMemento memento)
        {
            var productMemento = (ProductMemento)memento;

            Id = productMemento.Id;
            Version = productMemento.Version;
            Name = productMemento.Name;
            Price = new Money(productMemento.Price);
        }

        void IAmRestorable.RestoreSnapshot(IMemento memento)
        {
            if (memento == null)
            {
                return;
            }

            RestoreSnapshot(memento);
        }

        /// <summary>
        /// Redo 操作を実行し、データを取得します。
        /// </summary>
        public IMemento Redo()
        {
            if (!canRedo) return null;

            undo.Push(Now);
            Now = redo.Pop();

            return Now.Clone();
        }

		public bool Merge(IMemento otherMemento) {
			TextChangeMemento other = otherMemento as TextChangeMemento;
			if (other != null) {
				if (other.textContainer.Equals(textContainer)) {
					// Match, do not store anything as the initial state is what we want.
					return true;
				}
			}
			return false;
		}

		public bool Merge(IMemento otherMemento) {
			DrawableContainerBoundsChangeMemento other = otherMemento as DrawableContainerBoundsChangeMemento;
			if (other != null) {
				if (Objects.CompareLists<IDrawableContainer>(listOfdrawableContainer, other.listOfdrawableContainer)) {
					// Lists are equal, as we have the state already we can ignore the new memento
					return true;
				}
			}
			return false;
		}

        protected override void RestoreSnapshot(IMemento memento)
        {
            var portfolioMemento = (PortfolioMemento)memento;

            isOpen = portfolioMemento.IsOpen;

            foreach (var accountSnapshot in portfolioMemento.Accounts)
            {
                accounts.Add(RestoreEntity<Account>(accountSnapshot));
            }
        }

		public bool Merge(IMemento otherMemento) {
			ChangeFieldHolderMemento other = otherMemento as ChangeFieldHolderMemento;
			if (other != null) {
				if (other.drawableContainer.Equals(drawableContainer)) {
					if (other.fieldToBeChanged.Equals(fieldToBeChanged)) {
						// Match, do not store anything as the initial state is what we want.
						return true;
					}
				}
			}
			return false;
		}

        public IAggregate Build(Type type, Guid id, IMemento snapshot)
        {
            ConstructorInfo constructor = type.GetConstructor(
                BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] {typeof (Guid)}, null);

            if (constructor == null)
            {
                throw new InvalidOperationException(
                    string.Format("Aggregate {0} cannot be created: constructor with only id parameter not provided",
                                  type.Name));
            }
            return constructor.Invoke(new object[] {id}) as IAggregate;
        }

		public static void MigrateSettings(bool createTargetCategoryAndFields,
		                                   bool migrateFieldValues,
		                                   IMemento newState,
		                                   IMemento oldState)
		{
			Migrator migrator = new Migrator();

			if (createTargetCategoryAndFields)
			{
				migrator.EnsureTargetCategory(newState.CategoryName);
				migrator.EnsureFields(newState.CategoryName, new MigrationInfo(oldState, newState).AllFields);
			}

			if (migrateFieldValues)
			{
				migrator.Migrate(new MigrationInfo(oldState, newState));
			}
		}

        public MainForm( )
        {
            _memento = ObjectFactory.GetInstance<IMemento>() ;

            _model = ObjectFactory.GetInstance<IModel>() ;

            InitializeComponent();

            _model.ActiveLayerChanged += activeLayerChanged ;
            _model.NewModelLoaded += newModelLoaded ;
            _model.OnBeforeUnloadingModel += modelUnloading ;

            _memento.OnCommandEnded += mementoCommandEnded ;
            _memento.OnCommandUndone += mementoCommandUndone;
            _memento.OnCommandRedone += mementoCommandRedone;

            uiAssetsControl.AssetChosenByDoubleClicking += assetChosenByDoubleClicking ;
        }