public InterpolationState(SynchronizableTargetMember synchronizableTargetMember, TargetSynchronizerRoot targetSynchronizerRoot,
ISerializer serializer)
{
_synchronizableTargetMember = synchronizableTargetMember;
_targetSynchronizerRoot = targetSynchronizerRoot;
_serializer = serializer;
}
public TargetSynchronizer Synchronize(TargetSynchronizerRoot targetSynchronizerRoot, int referenceId, Type referenceType)
{
Type[] genericArgs = referenceType.GetGenericArguments();
Type observableDictionarySyncSourceObjectType = typeof(ObservableDictionaryTargetSynchronizer <,>).MakeGenericType(genericArgs);
return((TargetSynchronizer)Activator.CreateInstance(observableDictionarySyncSourceObjectType, targetSynchronizerRoot, referenceId, referenceType));
}
public void AddingItems_AfterClear_ShouldSynchronizeItems()
{
var hashSetTestObject = new NotifyPropertyChangedHashSetTestObject {
RandomIntProperty = 5
};
var SourceSynchronizerRoot = new SourceSynchronizerRoot(hashSetTestObject);
hashSetTestObject.Players.Clear();
var TargetSynchronizerRoot = new TargetSynchronizerRoot <NotifyPropertyChangedHashSetTestObject>(SourceSynchronizerRoot.WriteFullAndDispose());
hashSetTestObject.Players.Add(new NotifyPropertyChangedTestPlayer {
Name = "player1", Health = 100, Level = 30
});
hashSetTestObject.Players.Add(new NotifyPropertyChangedTestPlayer {
Name = "player2", Health = 44, Level = 1337
});
TargetSynchronizerRoot.Read(SourceSynchronizerRoot.WriteChangesAndDispose().SetTick(TimeSpan.FromMilliseconds(10)));
NotifyPropertyChangedHashSetTestObject targetGameWorld = TargetSynchronizerRoot.Reference;
AssertExtension.AssertCloneEqual(hashSetTestObject, targetGameWorld);
}
public void SynchronizingString_ThatIsNotReferenceEqual_Test()
{
var sourceGameWorld = new NotifyPropertyChangedTestGameWorld {
RandomIntProperty = 5
};
// Concatenating 1 to make sure the string is a new object
sourceGameWorld.Players.Add("player1", new NotifyPropertyChangedTestPlayer {
Name = "sameString" + 1, Health = 100, Level = 30
});
var SourceSynchronizerRoot = new SourceSynchronizerRoot(sourceGameWorld);
var TargetSynchronizerRoot = new TargetSynchronizerRoot <NotifyPropertyChangedTestGameWorld>(SourceSynchronizerRoot.WriteFullAndDispose());
sourceGameWorld.Players.Add("player2", new NotifyPropertyChangedTestPlayer {
Name = "sameString" + 1, Health = 44, Level = 1337
});
SynchronizationPacket writeChangesAndDispose = SourceSynchronizerRoot.WriteChangesAndDispose();
TargetSynchronizerRoot.Read(writeChangesAndDispose.SetTick(TimeSpan.Zero));
NotifyPropertyChangedTestGameWorld targetGameWorld = TargetSynchronizerRoot.Reference;
AssertExtension.AssertCloneEqual(sourceGameWorld, targetGameWorld);
}
public void AddingItems_AfterClear_ShouldSynchronizeItems()
{
var sourceGameWorld = new NotifyPropertyChangedTestGameWorld {
RandomIntProperty = 5
};
var sourceSynchronizerRoot = new SourceSynchronizerRoot(sourceGameWorld);
sourceGameWorld.Players.Clear();
var targetSynchronizerRoot = new TargetSynchronizerRoot <NotifyPropertyChangedTestGameWorld>(sourceSynchronizerRoot.WriteFullAndDispose());
sourceGameWorld.Players.Add("player1", new NotifyPropertyChangedTestPlayer {
Name = "player1", Health = 100, Level = 30
});
sourceGameWorld.Players.Add("player2", new NotifyPropertyChangedTestPlayer {
Name = "player2", Health = 44, Level = 1337
});
targetSynchronizerRoot.Read(sourceSynchronizerRoot.WriteChangesAndDispose().SetTick(TimeSpan.FromMilliseconds(10)));
NotifyPropertyChangedTestGameWorld targetGameWorld = targetSynchronizerRoot.Reference;
AssertExtension.AssertCloneEqual(sourceGameWorld, targetGameWorld);
}
public TakeSynchronizedOnEachUpdateState(SynchronizableTargetMember synchronizableTargetMember,
TargetSynchronizerRoot targetSynchronizerRoot)
{
_synchronizableTargetMember = synchronizableTargetMember;
_targetSynchronizerRoot = targetSynchronizerRoot;
_targetSynchronizerRoot.EndRead += TargetSynchronizerRootOnEndRead;
}
public void Synchronizing_PrivateField_Test()
{
var privateMock = new PrivateFieldMock(5);
var SourceSynchronizerRoot = new SourceSynchronizerRoot(privateMock);
var TargetSynchronizerRoot = new TargetSynchronizerRoot <PrivateFieldMock>(SourceSynchronizerRoot.WriteFullAndDispose());
Assert.Equal(5, TargetSynchronizerRoot.Reference.GetTestValue);
}
public void Synchronizing_PropertyWithoutSetterThroughConstructor_Synchronizes()
{
var getterOnlyConstructorMockSource = new NotifyPropertyChangedGetterOnlyConstructorMock(5);
var SourceSynchronizerRoot = new SourceSynchronizerRoot(getterOnlyConstructorMockSource);
var TargetSynchronizerRoot = new TargetSynchronizerRoot <NotifyPropertyChangedGetterOnlyConstructorMock>(SourceSynchronizerRoot.WriteFullAndDispose());
NotifyPropertyChangedGetterOnlyConstructorMock notifyPropertyChangedGetterOnlyConstructorMockRoot = TargetSynchronizerRoot.Reference;
Assert.Equal(getterOnlyConstructorMockSource.IntProperty, notifyPropertyChangedGetterOnlyConstructorMockRoot.IntProperty);
}
public void Synchronizing_Test()
{
var playerMock = new PlayerMock();
playerMock.Level = 5;
var sourceSynchronizerRoot = new SourceSynchronizerRoot(playerMock);
var targetSynchronizerRoot = new TargetSynchronizerRoot <PlayerMock>(sourceSynchronizerRoot.WriteFullAndDispose());
Assert.Equal(5, targetSynchronizerRoot.Reference.Level);
}
public void Clear_ShouldThrowNotImplemented()
{
var sourceDictionary = new ObservableDictionary <int, string>();
var SourceSynchronizerRoot = new SourceSynchronizerRoot(sourceDictionary);
byte[] data = SourceSynchronizerRoot.WriteFullAndDispose();
var TargetSynchronizerRoot = new TargetSynchronizerRoot <ObservableDictionary <int, string> >(data);
Assert.Throws <NotSupportedException>(() => { TargetSynchronizerRoot.Reference.Clear(); });
}
public ObservableHashSetTargetSynchronizer(TargetSynchronizerRoot targetSynchronizerRoot, int referenceId, Type referenceType) : base(referenceId)
{
_targetSynchronizerRoot = targetSynchronizerRoot;
_clock = _targetSynchronizerRoot.Clock;
base.Reference = Activator.CreateInstance(referenceType);
BaseObject.CollectionChanged += OnCollectionChanged;
_itemSerializer = targetSynchronizerRoot.Settings.Serializers.FindSerializerByType(typeof(TItem));
}
public SynchronizableTargetMember(
object declaringReference,
SynchronizableMember synchronizableMember,
TargetSynchronizerRoot targetSynchronizerRoot)
{
_synchronizableMember = synchronizableMember;
_targetSynchronizerRoot = targetSynchronizerRoot;
_declaringReference = declaringReference;
_state = ManualState.Instance;
}
public void Constructing_DependencyConstructorParameter_ResolvesFromDependencyResolver()
{
var dependencyConstructorMock = new NotifyPropertyChangedConstructedDependencyMock();
var SourceSynchronizerRoot = new SourceSynchronizerRoot(dependencyConstructorMock);
var TargetSynchronizerRoot = new TargetSynchronizerRoot <NotifyPropertyChangedConstructedDependencyMock>(SourceSynchronizerRoot.WriteFullAndDispose(), serviceProvider: new TestServiceProvider());
Assert.NotNull(TargetSynchronizerRoot.Reference.SomeService);
}
private static void RunMonoSyncTest(int entityCount)
{
Console.WriteLine();
Console.WriteLine($"Benchmark with {entityCount} entities");
// Initialization
Console.Write("Initializing: ");
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var world = new MonoSyncWorld();
var syncSourceRoot = new SourceSynchronizerRoot(world);
using (world.Entities.BeginMassUpdate())
{
for (int i = 0; i < entityCount; i++)
{
world.Entities.Add(i, new Entity());
}
}
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds + "MS");
stopwatch.Reset();
// Full write
Console.Write("Full write: ");
stopwatch.Start();
WriteSession fullWriteSession = syncSourceRoot.BeginWrite();
var syncTargetRoot = new TargetSynchronizerRoot <MonoSyncWorld>(fullWriteSession.WriteFull());
fullWriteSession.Dispose();
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds + "MS");
stopwatch.Reset();
int changes = entityCount / 10;
Console.Write($"{changes} changes write: ");
stopwatch.Start();
for (int i = 0; i < changes; i++)
{
world.Entities[i].XPos = 2;
}
using (WriteSession writeSession = syncSourceRoot.BeginWrite())
{
var data = writeSession.WriteChanges().SetTick(TimeSpan.Zero);
syncTargetRoot.Read(data);
}
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds + "MS");
}
public ObservableDictionaryTargetSynchronizer(TargetSynchronizerRoot targetSynchronizerRoot, int referenceId, Type baseType) : base(referenceId)
{
_targetSynchronizerRoot = targetSynchronizerRoot;
_clock = _targetSynchronizerRoot.Clock;
base.Reference = Activator.CreateInstance(baseType);
Reference.CollectionChanged += OnCollectionChanged;
_keySerializer = targetSynchronizerRoot.Settings.Serializers.FindSerializerByType(typeof(TKey));
_valueSerializer = targetSynchronizerRoot.Settings.Serializers.FindSerializerByType(typeof(TValue));
}
public void Initializing_NonConstructorPropertyWithoutSetter_ThrowsSetterNotFoundException()
{
var attributeMarkedMethodMockSource = new NotifyPropertyChangedGetterOnlyMock();
var SourceSynchronizerRoot = new SourceSynchronizerRoot(attributeMarkedMethodMockSource);
Assert.Throws <SetterNotAvailableException>(() =>
{
var TargetSynchronizerRoot = new TargetSynchronizerRoot(SourceSynchronizerRoot.WriteFullAndDispose());
});
}
public void Synchronizing_PropertiesUsedAsConstructorParameters_ShouldNotSynchronizeAfterConstructor()
{
var sourceConstructorMock = new NotifyPropertyChangedSynchronizeConstructorMock();
var SourceSynchronizerRoot = new SourceSynchronizerRoot(sourceConstructorMock);
var TargetSynchronizerRoot =
new TargetSynchronizerRoot <NotifyPropertyChangedSynchronizeConstructorMock>(SourceSynchronizerRoot.WriteFullAndDispose());
NotifyPropertyChangedSynchronizeConstructorMock targetConstructorMock = TargetSynchronizerRoot.Reference;
Assert.Equal(1, targetConstructorMock.DictionarySetCount);
}
public void Synchronizing_Array_Test()
{
int[,,] expected = new int[3, 3, 5]
{
{ { 1, 2, 6, 4, 5 }, { 2, 2, 3, 4, 5 }, { 3, 2, 3, 4, 5 } },
{ { 1, 2, 3, 4, 5 }, { 2, 2, 3, 4, 5 }, { 3, 2, 3, 4, 5 } },
{ { 1, 2, 3, 4, 5 }, { 99, 2, 3, 4, 5 }, { 3, 2, 3, 99, 3 } }
};
var SourceSynchronizerRoot = new SourceSynchronizerRoot(expected);
var TargetSynchronizerRoot = new TargetSynchronizerRoot <int[, , ]>(SourceSynchronizerRoot.WriteFullAndDispose());
Assert.Equal(expected, TargetSynchronizerRoot.Reference);
}
public void Changing_ConstructorProperty_Synchronizes()
{
var getterOnlyConstructorMockSource = new ConstructedPropertyChangeSynchronizationMock(5f);
var SourceSynchronizerRoot = new SourceSynchronizerRoot(getterOnlyConstructorMockSource);
var TargetSynchronizerRoot = new TargetSynchronizerRoot <ConstructedPropertyChangeSynchronizationMock>(SourceSynchronizerRoot.WriteFullAndDispose());
ConstructedPropertyChangeSynchronizationMock getterOnlyConstructorMockRoot = TargetSynchronizerRoot.Reference;
Assert.Equal(getterOnlyConstructorMockSource.Accessor, getterOnlyConstructorMockRoot.Accessor);
TargetSynchronizerRoot.Read(SourceSynchronizerRoot.WriteChangesAndDispose().SetTick(TimeSpan.Zero));
Assert.Equal(getterOnlyConstructorMockSource.Accessor, getterOnlyConstructorMockRoot.Accessor);
}
public void Synchronizing_MarkedParameterizedConstructor_InvokesConstructorWithParameters()
{
var sourceConstructorMock = new NotifyPropertyChangedSynchronizeConstructorMock();
var SourceSynchronizerRoot = new SourceSynchronizerRoot(sourceConstructorMock);
var TargetSynchronizerRoot =
new TargetSynchronizerRoot <NotifyPropertyChangedSynchronizeConstructorMock>(SourceSynchronizerRoot.WriteFullAndDispose());
TargetSynchronizerRoot.Read(SourceSynchronizerRoot.WriteChangesAndDispose().SetTick(TimeSpan.Zero));
NotifyPropertyChangedSynchronizeConstructorMock targetConstructorMock = TargetSynchronizerRoot.Reference;
Assert.True(targetConstructorMock.SyncConstructorCalled);
}
public ObjectTargetSynchronizer(TargetSynchronizerRoot targetSynchronizerRoot, int referenceId, Type referenceType) : base(referenceId)
{
_targetSynchronizerRoot = targetSynchronizerRoot;
Reference = FormatterServices.GetUninitializedObject(referenceType);
SynchronizableMember[] synchronizableMembers = targetSynchronizerRoot.SynchronizableMemberFactory.FromType(referenceType);
SynchronizableTargetMembers = new SynchronizableTargetMember[synchronizableMembers.Length];
for (var syncPropertyIndex = 0; syncPropertyIndex < synchronizableMembers.Length; syncPropertyIndex++)
{
SynchronizableMember synchronizableMember = synchronizableMembers[syncPropertyIndex];
var synchronizableTargetMember = new SynchronizableTargetMember(Reference, synchronizableMember, _targetSynchronizerRoot);
SynchronizableTargetMembers[syncPropertyIndex] = synchronizableTargetMember;
}
_targetSynchronizerRoot.EndRead += TargetSynchronizerRootOnEndRead;
}
public void Synchronizing_GetterManual_Resolves()
{
var sourceConstructorMock = new NotifyPropertyChangedManualGetterOnlyMock();
var sourceSynchronizerRoot = new SourceSynchronizerRoot(sourceConstructorMock);
Assert.Equal(5, sourceConstructorMock.SomeValue);
sourceConstructorMock.SomeValue = 6;
var TargetSynchronizerRoot = new TargetSynchronizerRoot <NotifyPropertyChangedManualGetterOnlyMock>(sourceSynchronizerRoot.WriteFullAndDispose());
NotifyPropertyChangedManualGetterOnlyMock targetConstructorMock = TargetSynchronizerRoot.Reference;
Assert.Equal(6, targetConstructorMock.SomeValue);
}
public void SynchronizingFull_TargetObjectEqualsSource()
{
var sourceGameWorld = new NotifyPropertyChangedTestGameWorld {
RandomIntProperty = 5
};
sourceGameWorld.Players.Add("player1", new NotifyPropertyChangedTestPlayer {
Name = "player1", Health = 100, Level = 30
});
sourceGameWorld.Players.Add("player2", new NotifyPropertyChangedTestPlayer {
Name = "player2", Health = 44, Level = 1337
});
var sourceSynchronizerRoot = new SourceSynchronizerRoot(sourceGameWorld);
var targetSynchronizerRoot = new TargetSynchronizerRoot <NotifyPropertyChangedTestGameWorld>(sourceSynchronizerRoot.WriteFullAndDispose());
NotifyPropertyChangedTestGameWorld targetGameWorld = targetSynchronizerRoot.Reference;
AssertExtension.AssertCloneEqual(sourceGameWorld, targetGameWorld);
}
public void Synchronizing_RollsBackTargetChangesPriorToSourceTick()
{
var sourceDictionary = new ObservableDictionary <int, string>();
var sourceSynchronizerRoot = new SourceSynchronizerRoot(sourceDictionary);
var targetSynchronizerRoot = new TargetSynchronizerRoot <ObservableDictionary <int, string> >(
sourceSynchronizerRoot.WriteFullAndDispose());
ObservableDictionary <int, string> targetDictionary = targetSynchronizerRoot.Reference;
targetDictionary.Add(1, "2");
targetSynchronizerRoot.Clock.OwnTick = TimeSpan.FromMilliseconds(5);
//Set tick older than client tick
byte[] changes = sourceSynchronizerRoot.WriteChangesAndDispose().SetTick(TimeSpan.FromMilliseconds(5));
targetSynchronizerRoot.Read(changes);
// Recently added item should be rolled back
Assert.Empty(targetDictionary);
}
public void Synchronizing_RollsBackTargetChangesPriorToSourceTick()
{
var source = new ObservableHashSet <string>();
var SourceSynchronizerRoot = new SourceSynchronizerRoot(source);
byte[] writeFullAndDispose = SourceSynchronizerRoot.WriteFullAndDispose();
var TargetSynchronizerRoot = new TargetSynchronizerRoot <ObservableHashSet <string> >(
writeFullAndDispose);
ObservableHashSet <string> target = TargetSynchronizerRoot.Reference;
target.Add("2");
TargetSynchronizerRoot.Clock.OwnTick = TimeSpan.FromMilliseconds(5);
//Set tick older than client tick
byte[] changes = SourceSynchronizerRoot.WriteChangesAndDispose().SetTick(TimeSpan.FromMilliseconds(6));
TargetSynchronizerRoot.Read(changes);
// Recently added item should be rolled back
Assert.Empty(target);
}
public void Synchronizing_ValueWithLowerTickThanDirtyTick_ShouldNotBeSet()
{
var sourceObject = new NotifyPropertyChangedLatestTickMock {
Value = 5
};
var SourceSynchronizerRoot = new SourceSynchronizerRoot(sourceObject);
var TargetSynchronizerRoot = new TargetSynchronizerRoot <NotifyPropertyChangedLatestTickMock>(SourceSynchronizerRoot.WriteFullAndDispose());
var targetObject = TargetSynchronizerRoot.Reference;
Assert.Equal(5, targetObject.Value);
TargetSynchronizerRoot.Clock.OwnTick = TimeSpan.FromMilliseconds(10);
targetObject.Value = 7;
sourceObject.Value = 6;
TargetSynchronizerRoot.Read(SourceSynchronizerRoot.WriteChangesAndDispose().SetTick(TimeSpan.FromMilliseconds(9)));
Assert.Equal(7, targetObject.Value);
TargetSynchronizerRoot.Read(SourceSynchronizerRoot.WriteChangesAndDispose().SetTick(TimeSpan.FromMilliseconds(11)));
Assert.Equal(6, targetObject.Value);
}
public TargetSynchronizer Synchronize(TargetSynchronizerRoot targetSynchronizerRoot, int referenceId, Type referenceType)
{
return(new ArrayTargetSynchronizer(targetSynchronizerRoot, referenceId, referenceType));
}
public TargetSynchronizer Synchronize(TargetSynchronizerRoot targetSynchronizerRoot, int referenceId, Type referenceType)
{
return(new StringTargetSynchronizer(referenceId));
}
public HighestTickState(SynchronizableTargetMember synchronizableTargetMember, TargetSynchronizerRoot targetSynchronizerRoot)
{
_synchronizableTargetMember = synchronizableTargetMember;
_targetSynchronizerRoot = targetSynchronizerRoot;
}
public TargetSynchronizer Synchronize(TargetSynchronizerRoot targetSynchronizerRoot, int referenceId, Type referenceType)
{
return(new NotifyPropertyChangedTargetSynchronizer(targetSynchronizerRoot, referenceId, referenceType));
}
