void IOrginator.SetMemento(IMemento memento)
{
var bankCardMemento = (BankCardMemento)memento;
Id = bankCardMemento.Id;
_accountId = bankCardMemento.AccountId;
_disabled = bankCardMemento.Disabled;
}
public void MakeBackup(IMemento memento)
{
Console.WriteLine("-------------Saving state--------------------");
memento.getGameState().DescribeGame();
Console.WriteLine("---------------------------------------------");
mementos.Add(memento);
}
public void Restore(IMemento memento)
{
if (memento is EditorMemento m)
{
state = m.GetState();
}
}
public void Apply(float interpolationFactor, bool isNewFrame, IMemento nextFrame)
{
Hero target = (Hero)Target;
if (nextFrame != null)
{
float thisInterp = 1 - interpolationFactor;
float nextInterp = interpolationFactor;
HeroMemento next = (HeroMemento)nextFrame;
if (teleportedThisFrame)
{
target.position = position;
}
else
{
target.position = position * thisInterp + next.position * nextInterp;
}
}
else
{
target.position = position;
}
if (alive)
{
if (!target.Alive)
{
target.revive();
}
target.health = health;
}
target.direction = direction;
target.rotation = rotation;
}
public async Task Find_restores_aggregate_using_memento_if_found()
{
// Arrange
var user = fixture.Create <FakeUser>();
IMemento memento = user.SaveToMemento();
user.ChangeUsername(fixture.Create("username"));
Mock.Get(mementoStore)
.Setup(x => x.Find <FakeUser>(user.Id, CancellationToken.None))
.ReturnsAsync(memento);
Mock.Get(eventStore)
.Setup(
x =>
x.LoadEvents <FakeUser>(user.Id, 1, CancellationToken.None))
.ReturnsAsync(user.PendingEvents.Skip(1))
.Verifiable();
// Act
FakeUser actual = await sut.Find(user.Id, CancellationToken.None);
// Assert
Mock.Get(eventStore).Verify();
actual.ShouldBeEquivalentTo(
user, opts => opts.Excluding(x => x.PendingEvents));
}
void IEventSource.RestoreSnapshot(IMemento memento)
{
RestoreSnapshot(memento);
Id = memento.Id;
_version = memento.Version;
}
public TestOriginatorEntity(Guid id, IMemento memento, IEnumerable <IVersionedEvent> history)
{
this.Events = new List <IVersionedEvent>();
this.Memento = memento;
this.History = history;
this.Id = id;
}
public override void ReadExternal(IMemento memento, ExternalizeContext context)
{
base.ReadExternal(memento, context);
SourceDecoration = memento.ReadExternalizable("SourceDecoration") as IEdgeDecoration;
TargetDecoration = memento.ReadExternalizable("TargetDecoration") as IEdgeDecoration;
}
protected TEntity RestoreEntity <TEntity>(IMemento memento) where TEntity : class, IEntity
{
IEntity entity = ActivatorHelper.CreateInstanceUsingNonPublicConstructor <TEntity>(this, memento.Identity);
entity.RestoreSnapshot(memento);
return((TEntity)entity);
}
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)
{
//if (type == typeof(IMyInterface))
// return new MyAggregate();
//else
return Activator.CreateInstance(type) as IAggregate;
}
public override void ReadExternal(IMemento memento, ExternalizeContext context)
{
base.ReadExternal(memento, context);
_angle = memento.ReadFloat("Angle");
_isFlippedHorizontal = memento.ReadBool("IsFlippedHorizontal");
_isFlippedVertical = memento.ReadBool("IsFlippedVertical");
}
public void ReadExternal(IMemento memento, ExternalizeContext context)
{
_saveTo = memento.ReadSerializable("ExternalizableProxy.SaveTo") as Action <T, IMemento, ExternalizeContext>;
_loadFrom = memento.ReadSerializable("ExternalizableProxy.LoadFrom") as Func <IMemento, ExternalizeContext, T>;
_real = _loadFrom(memento, context);
}
private async Task SaveMemento(
Guid sourceId,
IMemento memento,
CancellationToken cancellationToken)
{
using (MementoStoreDbContext context = _dbContextFactory.Invoke())
{
Memento entity = await context
.Mementoes
.Where(m => m.AggregateId == sourceId)
.SingleOrDefaultAsync(cancellationToken)
.ConfigureAwait(false);
if (entity == null)
{
entity = new Memento {
AggregateId = sourceId
};
context.Mementoes.Add(entity);
}
entity.MementoJson = _serializer.Serialize(memento);
await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
}
// ========================================
// method
// ========================================
// === IPersistable ==========
public override void WriteExternal(IMemento memento, ExternalizeContext context)
{
base.WriteExternal(memento, context);
memento.WriteFloat("Angle", _angle);
memento.WriteBool("IsFlippedHorizontal", _isFlippedHorizontal);
memento.WriteBool("IsFlippedVertical", _isFlippedVertical);
}
/// <summary>
/// 加载
/// </summary>
public override void LoadState(IMemento memento)
{
SectorBarDesps.Clear();
for (int Index = 0; Index < memento.ChildCount; Index++)
{
IMemento childMemento = memento.GetChild(Index);
String sectorBarType = childMemento.GetString("BarType") ?? String.Empty;
if (String.IsNullOrEmpty(sectorBarType))
{
continue;
}
else
{
List <SectorBarButtonDescription> btnDesp = new List <SectorBarButtonDescription>();
for (int subIndex = 0; subIndex < childMemento.ChildCount; subIndex++)
{
IMemento subChild = childMemento.GetChild(subIndex);
SectorBarButtonDescription barBtn = new SectorBarButtonDescription();
barBtn.LoadState(subChild);
btnDesp.Add(barBtn);
}
SectorBarDesps[sectorBarType] = btnDesp;
}
}
}
/// <summary>
/// 加载
/// </summary>
public override void LoadState(IMemento memento)
{
Name = memento.GetString("Name");
Text = memento.GetString("Text");
RefSector = memento.GetString("RefSector");
String typeInfo = memento.GetString("MenuBoxItemType");
Assembly assembly = LoadAssembly(typeInfo.Split(',')[1]);
MenuBoxItemType = assembly.GetType(typeInfo.Split(',')[0]);
SectorList.Clear();
for (int Index = 0; Index < memento.ChildCount; Index++)
{
IMemento childMemento = memento.GetChild(Index);
MenuListItem menuListItem = new MenuListItem();
menuListItem.LoadState(childMemento);
//确保只有一个是选中状态
if (menuListItem.IsChecked)
{
foreach (MenuListItem item in SectorList)
{
item.IsChecked = false;
}
}
SectorList.Add(menuListItem);
}
}
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 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 void Apply(float interpolationFactor, bool isNewFrame, IMemento nextFrame)
{
Level target = (Level)Target;
if (isNewFrame) //only apply frame if it's for the first time, ignore intermediate interpolations
{
target.enemyGrid = enemyGrid;
for (int i = 0; i < target.drilledWalls.Count; i++)
{
Point p = target.drilledWalls[i];
if (!drilledWalls.Contains(p))
{
target.undrillWall(p.X, p.Y);
i--;
}
}
}
for (int i = 0; i < enemyMementos.Length; i++)
{
IMemento nextEnemyFrame = null;
if (nextFrame != null)
{
nextEnemyFrame = ((LevelMemento)nextFrame).enemyMementos[i];
}
enemyMementos[i].Apply(interpolationFactor, isNewFrame, nextEnemyFrame);
}
}
void ITimeBody.RestoreMemento(IMemento o)
{
var memento = (Memento)o;
moveSpeed = memento.MoveSpeed;
score = memento.Score;
}
static void Main(string[] args)
{
Deck deck = new Deck();
// Save initial deck
Console.WriteLine("Saving...");
IMemento memento = deck.Memento;
// Shuffle deck and print
deck.Shuffle();
foreach (Card card in deck)
{
Console.Write($"{card} ");
}
Console.WriteLine();
// Restore initial deck and print
Console.WriteLine("Restoring...");
deck.Memento = memento;
foreach (Card card in deck)
{
Console.Write($"{card} ");
}
Console.WriteLine();
}
public void Save()
{
// ToDo
IMemento memento = StockValue.Save();
Mementos.Add(memento);
}
public void TestMethod()
{
Originator ori = new Originator();
Console.WriteLine(ori.Current.X + " " + ori.Current.Y);
IMemento <Position> m1 = ori.Memento;
ori.DecreaseX();
ori.IncreaseY();
Console.WriteLine(ori.Current.X + " " + ori.Current.Y);
Console.WriteLine(m1.State.X + " " + m1.State.Y);
IMemento <Position> m2 = ori.Memento;
Console.WriteLine(m2.State.X + " " + m2.State.Y);
ori.Memento = m1;
Console.WriteLine(ori.Current.X + " " + ori.Current.Y);
CareTaker <Position> care = new CareTaker <Position>();
care.Push(ori.Memento);
Console.ReadLine();
}
public void Undo(GameOriginator gameOriginator)
{
IMemento lastMemento = mementos.Last();
mementos.Remove(lastMemento);
gameOriginator.RestoreGame(lastMemento);
}
private async Task <T> PublishAndRestore(
Guid sourceId, CancellationToken cancellationToken)
{
await _eventPublisher
.PublishPendingEvents <T>(sourceId, cancellationToken)
.ConfigureAwait(false);
IMemento memento = null;
if (_mementoStore != null && _mementoEntityFactory != null)
{
memento = await _mementoStore
.Find <T>(sourceId, cancellationToken)
.ConfigureAwait(false);
}
IEnumerable <IDomainEvent> domainEvents = await _eventStore
.LoadEvents <T>(sourceId, memento?.Version ?? 0, cancellationToken)
.ConfigureAwait(false);
return
(memento == null
? domainEvents.Any()
? _entityFactory.Invoke(sourceId, domainEvents)
: default(T)
: _mementoEntityFactory.Invoke(sourceId, memento, domainEvents));
}
// ========================================
// method
// ========================================
// === IPersistable ==========
public override void WriteExternal(IMemento memento, ExternalizeContext context)
{
base.WriteExternal(memento, context);
memento.WriteExternalizable("SourceDecoration", _sourceDecoration);
memento.WriteExternalizable("TargetDecoration", _targetDecoration);
}
public void Apply(float interpolationFactor, bool isNewFrame, IMemento nextFrame)
{
Enemy target = (Enemy)Target;
if (nextFrame != null)
{
float thisInterp = 1 - interpolationFactor;
float nextInterp = interpolationFactor;
EnemyMemento next = (EnemyMemento)nextFrame;
target.position = position * thisInterp + next.position * nextInterp;
deathEmitterMemento.Apply(interpolationFactor, isNewFrame, ((EnemyMemento)nextFrame).deathEmitterMemento);
}
else
{
target.position = position;
deathEmitterMemento.Apply(interpolationFactor, isNewFrame, null);
}
target.state = state;
target.targetedAI.Target = AItarget;
target.health = health;
target.direction = direction;
target.rotation = rotation;
target.dying = dying;
target.maskingColor = Color.Lerp(Color.Black, Color.White, health / STARTING_HEALTH);
}
public async Task Find_restores_aggregate_using_memento_if_found()
{
// Arrange
var user = new FakeUser(id: Guid.NewGuid(), username: Guid.NewGuid().ToString());
IMemento memento = user.SaveToMemento();
user.ChangeUsername(username: Guid.NewGuid().ToString());
IMementoStore mementoStore = Mock.Of <IMementoStore>();
Mock.Get(mementoStore)
.Setup(x => x.Find <FakeUser>(user.Id, default))
.ReturnsAsync(memento);
ISqlEventStore eventStore = Mock.Of <ISqlEventStore>();
Mock.Get(eventStore)
.Setup(x => x.LoadEvents <FakeUser>(user.Id, 1, default))
.ReturnsAsync(user.FlushPendingEvents().Skip(1))
.Verifiable();
var sut = new SqlEventSourcedRepository <FakeUser>(
eventStore,
Mock.Of <ISqlEventPublisher>(),
mementoStore,
FakeUser.Factory,
FakeUser.Factory);
// Act
FakeUser actual = await sut.Find(user.Id, default);
// Assert
Mock.Get(eventStore).Verify();
actual.ShouldBeEquivalentTo(user);
}
private async Task <T> RehydrateWithMemento(Guid sourceId, IMemento memento, CancellationToken cancellationToken)
{
IEnumerable <IDomainEvent> domainEvents = await
_eventStore.LoadEvents <T>(sourceId, memento.Version, cancellationToken).ConfigureAwait(false);
return(_mementoEntityFactory.Invoke(sourceId, memento, domainEvents));
}
public void RestoreTest_Simple()
{
// Create a type
var testStructType = registry.CreateType(UTinyId.New(), "TestStructType", UTinyTypeCode.Struct);
var testRef = (UTinyType.Reference)testStructType;
IMemento initialState = null;
// Register for changed events
caretaker.OnObjectChanged += (originator, memento) =>
{
initialState = memento;
};
// Update to get the initial state; flush changes
caretaker.Update();
Assert.NotNull(initialState);
{
// Make some changes to the created type
testStructType.Name = "OtherTestStructType";
Assert.AreEqual(testStructType.Name, "OtherTestStructType");
// revert them
testStructType.Restore(initialState);
testStructType = testRef.Dereference(context.Registry);
Assert.NotNull(testStructType);
Assert.AreEqual(testStructType.Name, "TestStructType");
}
}
/// <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;
}
private void HandleStacks(Stack <IMemento> fromStack, Stack <IMemento> toStack)
{
var previousState = fromStack.Pop();
toStack.Push(CurrentState);
CurrentState = previousState;
}
void IAggregateRoot.RestoreSnapshot(IMemento memento)
{
RestoreSnapshot(memento);
Key = memento.Key;
Version = memento.Version;
}
void IAmRestorable.RestoreSnapshot(IMemento memento)
{
if (memento == null)
{
return;
}
RestoreSnapshot(memento);
}
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);
}
/// <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 CustomPropertiesGridControl( )
{
InitializeComponent( ) ;
if( !Helper.IsInDesignMode )
{
_memento = IoC.Memento ;
_model = ObjectFactory.GetInstance<IModel>( ) ;
_model.SelectionChanged += ( sender, e1 ) => refresh( e1.ItemsAffected ) ;
_model.ItemChanged += ( sender1, e2 ) => refresh( e2.ItemsAffected ) ;
_model.ActiveLayerChanged += ( s, e ) => refresh(
new[ ]
{
_model.Level.ActiveLayer
} ) ;
}
_grid = new PropertyGrid
{
Dock = DockStyle.Fill,
Visible = false,
PropertySort = PropertySort.Categorized,
ToolbarVisible = false
} ;
_grid.PropertyValueChanged += gridPropertyValueChanged ;
_grid.SelectedObjectsChanged += gridSelectObjectsChanged;
_label = new Label
{
Dock = DockStyle.Fill,
Text = @"Select a single item to view its properties",
Visible = true,
} ;
Controls.Add( _grid ) ;
Controls.Add( _label ) ;
var site = new SimpleSite
{
Name = @"GridSite",
Component = _grid,
} ;
_glyphService = new GlyphService( ) ;
_glyphService.QueryPropertyUIValueItems += verifyDataErrorInfo ;
site.AddService<IPropertyValueUIService>( _glyphService ) ;
_grid.Site = site ;
}
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;
}
public bool Merge(IMemento otherMemento)
{
return false;
}
void IOrginator.SetMemento(IMemento memento)
{
SetMemento(memento);
}
public SnapShot(Guid eventProviderId, int version, IMemento memento)
{
EventProviderId = eventProviderId;
Version = version;
Memento = memento;
}
protected override void RestoreSnapshot(IMemento memento)
{
var snapshot = (AccountSnapshot)memento;
balance = snapshot.Balance;
}
protected abstract void SetMemento(IMemento memento);
Stack<IMemento> undo = new Stack<IMemento>(); //Undo 用スタック
#endregion Fields
#region Constructors
/************************↑ 基本変数 ↑************************/
/*********************↓ コンストラクタ ↓*********************/
/// <summary>
/// 初期データを指定して UnReDoInvoker オブジェクトを作成します。
/// </summary>
/// <param name="imem">初期データ</param>
public UnReDoInvoker(IMemento imem)
{
NoneData = Now = imem;
}
/// <summary>
/// すべてのデータを消去します。
/// </summary>
public void AllClear()
{
undo.Clear();
redo.Clear();
Now = NoneData;
}
/// <summary>
/// データを追加します。
/// </summary>
/// <param name="mem">追加するデータ</param>
public void Setmemento(IMemento mem)
{
redo.Clear();
undo.Push(Now);
Now = mem;
}
public void when_reading_entity_then_rehydrates()
{
var newEvents = new IVersionedEvent[]
{
new TestEvent { SourceId = id, Version = 2, Foo = "Baz" }
};
var serialized = newEvents.Select(x => new EventData { Version = x.Version, Payload = Serialize(x) });
this.id = Guid.NewGuid();
var eventStore = new Mock<IEventStore>();
this.memento = Mock.Of<IMemento>(x => x.Version == 1);
var cache = new MemoryCache(Guid.NewGuid().ToString());
cache.Add("TestOriginatorEntity_" + id.ToString(), new Tuple<IMemento, DateTime?>(this.memento, null), DateTimeOffset.UtcNow.AddMinutes(10));
eventStore.Setup(x => x.Load(It.IsAny<string>(), 2)).Returns(serialized);
var sut = new AzureEventSourcedRepository<TestOriginatorEntity>(eventStore.Object, Mock.Of<IEventStoreBusPublisher>(), new JsonTextSerializer(), new StandardMetadataProvider(), cache);
var entity = sut.Find(id);
Assert.NotNull(entity);
Assert.Equal(id, entity.Id);
Assert.Equal(memento, entity.Memento);
Assert.Equal(newEvents, entity.History, new TestEventComparer());
}
public when_saving_memento_originator_entity()
{
this.eventStore = new Mock<IEventStore>();
this.publisher = new Mock<IEventStoreBusPublisher>();
this.cache = new MemoryCache(Guid.NewGuid().ToString());
var sut = new AzureEventSourcedRepository<TestOriginatorEntity>(eventStore.Object, publisher.Object, new JsonTextSerializer(), new StandardMetadataProvider(), this.cache);
this.id = Guid.NewGuid();
this.memento = Mock.Of<IMemento>();
var entity = new TestOriginatorEntity
{
Id = id,
Events =
{
new TestEvent { SourceId = id, Version = 1, Foo = "Bar" },
new TestEvent { SourceId = id, Version = 2, Foo = "Baz" }
},
Memento = memento,
};
sut.Save(entity, "correlation");
}
