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 ;
        }

        public LevelExplorerControl( )
        {
            InteractsWithModel = true ;

            InitializeComponent( ) ;

            if( !Helper.IsInDesignMode )
            {
                var imageRepository = ObjectFactory.GetNamedInstance<IImageRepository>( @"iconImages" ) ;

                Assembly thisAssembly = Assembly.GetExecutingAssembly(  ) ;

                Images.SummonIcon( thisAssembly, LAYER_ICON_ACTIVE_NAME ) ;
                Images.SummonIcon( thisAssembly,LAYER_ICON_NONACTIVE_NAME ) ;
                Images.SummonIcon( thisAssembly,LEVEL_ICON_NAME ) ;

                _imageList = imageRepository.CreateImageList( ) ;

                _model = ObjectFactory.GetInstance<IModel>( ) ;
                _memento = ObjectFactory.GetInstance<IMemento>( ) ;

                subscribeToModelEvents( ) ;
            }

            uiTree.AllowDrop = true ;
            uiTree.CheckBoxes = true ;
            uiTree.FullRowSelect = true ;
            uiTree.HideSelection = false ;
            uiTree.HotTracking = true ;
            uiTree.ImageList = _imageList ;
            uiTree.LabelEdit = true ;
            uiTree.Name = "uiEntityTree" ;
            uiTree.ShowNodeToolTips = true ;

            uiTree.KeyDown += entityTreeKeyDown ;
            uiTree.MouseDown += entityTreeMouseDown ;
            uiTree.AfterLabelEdit += entityTreeAfterLabelEdit ;
            uiTree.AfterCheck += entityTreeAfterCheck ;
            uiTree.AfterSelect += entityTreeAfterSelect ;
            uiTree.DragDrop += entityTreeDragDrop ;
            uiTree.DragOver += entityTreeDragOver ;
            uiTree.ItemDrag += entityTreeItemDrag ;
        }

 public void ApplyMemento(IMemento memento)
 {
     if (memento == null) throw new ArgumentNullException("memento");
     TextBoxMemento textBoxMemento;
     try
     {
         textBoxMemento = (TextBoxMemento) memento;
     }
     catch (InvalidCastException ex)
     {
         throw new IncompatibleMementoException(
             string.Format(
                 "Only memento of type [{0}] be applied to [{1}] ",
                 memento.GetType(),
                 GetType()),
             ex);
     }
     Text = textBoxMemento.Text;
     MoveCaretTo(textBoxMemento.CaretPostition);
     Select(textBoxMemento.Selection);
 }

		public MigrationInfo(IMemento oldState, IMemento newState)
		{
			if (oldState == null)
			{
				throw new ArgumentNullException("oldState");
			}

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

			SourceCategoryName = oldState.CategoryName;
			TargetCategoryName = newState.CategoryName;

			ChangedFieldNames = MementoHelper.GetChangedFieldNames(oldState, newState);

			AllFields = new List<FieldInfo>();
			foreach (var newField in newState.Fields)
			{
				AllFields.Add(newField.Value);
			}
		}

		internal static Dictionary<string, string> GetChangedFieldNames(IMemento oldState, IMemento newState)
		{
			Dictionary<string, string> result = new Dictionary<string, string>();

			foreach (var oldField in oldState.Fields)
			{
				// Skip empty old field values.
				if (String.IsNullOrEmpty(oldField.Value.FieldName))
				{
					continue;
				}

				// Skip field names that did not change.
				if (String.Equals(oldField.Value.FieldName, newState.Fields[oldField.Key].FieldName))
				{
					continue;
				}

				result.Add(oldField.Value.FieldName, newState.Fields[oldField.Key].FieldName);
			}

			return result;
		}

 void IOrginator.SetMemento(IMemento memento)
 {
     SetMemento(memento);
 }