internal Enumerator(IList <D> dataList, ISerializationService ss)
{
_dataList = dataList;
_ss = ss;
_nextIndex = 0;
_current = null;
}
public NetworkOperationWriter(OperationMap map, ISerializationService serializer, IOperationTransport transport)
{
_map = map;
_serializer = serializer;
_transport = transport;
}
private void SaveGameDescriptor(Stream stream)
{
ISerializationService service = Services.GetService <ISerializationService>();
if (service != null)
{
XmlWriterSettings settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace,
OmitXmlDeclaration = true
};
using (System.Xml.XmlWriter xmlWriter = System.Xml.XmlWriter.Create(stream, settings))
{
xmlWriter.WriteStartDocument();
XmlSerializer xmlSerializer = service.GetXmlSerializer <GameSaveDescriptor>();
xmlSerializer.Serialize(xmlWriter, this.GameSaveDescriptor);
xmlWriter.WriteEndDocument();
xmlWriter.Flush();
xmlWriter.Close();
}
}
}
public virtual void Setup()
{
_serializationService = new SerializationServiceBuilder(new NullLoggerFactory())
.AddDefinitions(new ConstantSerializerDefinitions())
.AddDefinitions(new DefaultSerializerDefinitions())
.Build();
}
protected BaseFileProvider(
ISerializationService serializationService,
IFileService fileService)
{
_serializationService = serializationService;
_fileService = fileService;
}
private long _lastExpire; // last time expiration ran
/// <summary>
/// Initializes a new instance of the <see cref="NearCacheBase"/> class.
/// </summary>
/// <param name="name">The name of the cache.</param>
/// <param name="cluster">The cluster.</param>
/// <param name="serializationService">The localization service.</param>
/// <param name="loggerFactory">A logger factory.</param>
/// <param name="nearCacheNamedOptions">NearCache options.</param>
protected NearCacheBase(string name, Cluster cluster, ISerializationService serializationService, ILoggerFactory loggerFactory, NearCacheNamedOptions nearCacheNamedOptions)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException(ExceptionMessages.NullOrEmpty, nameof(name));
}
Name = name;
Cluster = cluster ?? throw new ArgumentNullException(nameof(cluster));
SerializationService = serializationService ?? throw new ArgumentNullException(nameof(serializationService));
LoggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
Options = nearCacheNamedOptions ?? throw new ArgumentNullException(nameof(nearCacheNamedOptions));
_entries = new ConcurrentAsyncDictionary <IData, NearCacheEntry>();
Statistics = new NearCacheStatistics();
_lastExpire = Clock.Never;
_maxSize = nearCacheNamedOptions.MaxSize;
_maxIdleMilliseconds = nearCacheNamedOptions.MaxIdleSeconds * 1000;
InMemoryFormat = nearCacheNamedOptions.InMemoryFormat;
_timeToLive = nearCacheNamedOptions.TimeToLiveSeconds * 1000;
_evictionPolicy = nearCacheNamedOptions.EvictionPolicy;
_evictionComparer = GetEvictionComparer(_evictionPolicy);
_evictionPercentage = nearCacheNamedOptions.EvictionPercentage;
_cleanupInterval = nearCacheNamedOptions.CleanupPeriodSeconds * 1000;
}
public ImpoundService(
IDataService data,
ISerializationService serialization)
{
_data = data;
_serialization = serialization;
}
internal ByteArrayObjectDataOutput(int size, ISerializationService service, ByteOrder byteOrder)
{
_initialSize = size;
Buffer = new byte[size];
_service = service;
_isBigEndian = byteOrder == ByteOrder.BigEndian;
}
public Settings()
{
InitializeComponent();
NavigationCacheMode = NavigationCacheMode.Required;
_SerializationService = SerializationService.Json;
}
/// <param name="cachingService">The backing caching service to use</param>
/// <param name="serializationService">A serialization service to use for reading configurations</param>
/// <param name="configurationLifeSpan">How long cached configurations should be valid for</param>
public ConfigurationCacheBase(ICachingService cachingService, ISerializationService serializationService,
TimeSpan?configurationLifeSpan = null)
{
CachingService = cachingService;
SerializationService = serializationService;
ConfigurationLifeSpan = configurationLifeSpan;
}
public SerializationManager(
ISerializationService serializationService,
IFileBrowserService fileBrowserService)
{
this.serialization = serializationService;
this.browser = fileBrowserService;
}
/// <summary>
/// Initialize a new instance of class <see cref="CacheService{T}"/>.
/// </summary>
public CacheService(IStorageService storageService, ISerializationService serializationService)
{
cache = new Dictionary <Guid, T>();
this.storageService = storageService;
this.serializationService = serializationService;
}
/// <inheritdoc />
/// <summary>
/// Initializes a new instance of the <see cref="T:MovieLibraryApp.Views.MovieDetailsPage" /> class.
/// </summary>
public MovieDetailsPage()
{
InitializeComponent();
NavigationCacheMode = NavigationCacheMode.Enabled;
_mdvm = new MovieDetailsViewModel();
_serializationService = SerializationService.Json;
}
public DefaultOpmlService(
ICategoryManager categoryManager,
ISerializationService serializationService)
{
_categoryManager = categoryManager;
_serializationService = serializationService;
}
public void DeathService_BindPlayerSoul_ShouldUpdateDatabaseAndNotCallFloatingTextStringOnCreature()
{
// Arrange
int callCount = -1;
INWScript script = Substitute.For <INWScript>();
INWNXCreature nwnxCreature = Substitute.For <INWNXCreature>();
ISerializationService serialization = Substitute.For <ISerializationService>();
IRandomService random = Substitute.For <IRandomService>();
IColorTokenService color = Substitute.For <IColorTokenService>();
script.When(x => x.FloatingTextStringOnCreature(Arg.Any <string>(), Arg.Any <Object>(), Arg.Any <int>())).Do(x => callCount++);
DeathService service = new DeathService(_db, script, serialization, random, color);
NWPlayer player = Substitute.For <NWPlayer>(script, nwnxCreature);
player.Object.Returns(x => new Object());
player.GlobalID.Returns("123");
player.Position.Returns(x => new Vector(43.2f, 22.2f, 87.0f));
player.Facing.Returns(x => 320.666f);
player.Area.Returns(x => new NWArea(script));
player.Area.Tag.Returns("a_fake_area_tag");
// Act
service.BindPlayerSoul(player, false);
var result = _db.PlayerCharacters.Single(x => x.PlayerID == "123");
// Assert
Assert.AreEqual(43.2f, result.RespawnLocationX);
Assert.AreEqual(22.2f, result.RespawnLocationY);
Assert.AreEqual(87.0f, result.RespawnLocationZ);
Assert.AreEqual(320.666f, result.RespawnLocationOrientation);
Assert.AreEqual("a_fake_area_tag", result.RespawnAreaTag);
Assert.AreEqual(-1, callCount);
}
public MvvmViewModel()
{
_serializationService = Injector.Get <ISerializationService>();
Items = new ObservableCollection <ItemViewModel>();
InitializeCommands();
}
/// <exception cref="System.IO.IOException" />
internal static void TestDifferentClassVersionsUsingDataWriteAndRead(ISerializationService serializationService,
ISerializationService serializationService2)
{
var p1 = new NamedPortable("portable-v1", 111);
var data = serializationService.ToData(p1);
// emulate socket write by writing data to stream
var @out = serializationService.CreateObjectDataOutput(1024);
@out.WriteData(data);
var bytes = @out.ToByteArray();
// emulate socket read by reading data from stream
var @in = serializationService2.CreateObjectDataInput(bytes);
data = @in.ReadData();
// read data
var object1 = serializationService2.ToObject <object>(data);
// serialize new portable version
var p2 = new NamedPortableV2("portable-v2", 123);
var data2 = serializationService2.ToData(p2);
// de-serialize back using old version
var object2 = serializationService.ToObject <object>(data2);
Assert.IsNotNull(object1, "object1 should not be null!");
Assert.IsNotNull(object2, "object2 should not be null!");
Assert.IsInstanceOf <NamedPortableV2>(object1, "Should be instance of NamedPortableV2: " + object1.GetType());
Assert.IsInstanceOf <NamedPortable>(object2, "Should be instance of NamedPortable: " + object2.GetType());
}
public static PagingPredicateHolder Of(IPredicate predicate, ISerializationService serializationService)
{
if (predicate is null)
{
return(null);
}
if (predicate is PartitionPredicate partitionPredicate)
{
if (partitionPredicate.Target is PagingPredicate partitionPagingPredicate)
{
var partitionKeyData = serializationService.ToData(partitionPredicate.PartitionKey);
return(BuildHolder(serializationService, partitionPagingPredicate, partitionKeyData));
}
throw new InvalidOperationException("PartitionPredicate Target is not a PagingPredicate.");
}
if (predicate is PagingPredicate pagingPredicate)
{
return(BuildHolder(serializationService, pagingPredicate, null));
}
throw new InvalidOperationException("Predicate is neither a PartitionPredicate nor a PagingPredicate.");
}
internal static void TestPreDefinedDifferentVersions(ISerializationService serializationService,
ISerializationService serializationService2, MainPortable mainPortable)
{
var data = serializationService.ToData(mainPortable);
Assert.AreEqual(mainPortable, serializationService2.ToObject <MainPortable>(data));
}
public MainViewModel(IMscsService mscsService, ISerializationService serializationService,
IPhotoService photoService, IMessageBoxService messageBoxService,
ITextToSpeechService textToSpeechService, ILocationService locationService,
IGeocodingService geocodingService, ISpeechToTextService speechToTextService,
IPublicTransportServices publicTransportServices,
ITranslationService translationService,
IMvxAndroidCurrentTopActivity activity)
{
this._mscsService = mscsService;
this._photoService = photoService;
this._messageBoxService = messageBoxService;
this._textToSpeechService = textToSpeechService;
this._locationService = locationService;
this._geocodingService = geocodingService;
this._speechToTextService = speechToTextService;
this._publicTransportServices = publicTransportServices;
this._translationService = translationService;
this._checkNetwork = new CheckInternetConnection();
this._checkLocation = new CheckLocationAvailability();
this._speechToTextService.MessageChanged += HandleMessageChanged;
this._photoService.PhotoChanged += HandlePhotoChanged;
_textToSpeechService.Speak(
"Witaj w aplikacji blind. Tapnij na ekran i powiedz komende dla danej funkcji. Aby uzyskaæ informacjê o dostêpnych funkcjach tapnij w ekran i powiedz menu");
CheckSettingsAfterStart();
}
public OpmlService(
ICategoriesRepository categoriesRepository,
ISerializationService serializationService)
{
_categoriesRepository = categoriesRepository;
_serializationService = serializationService;
}
private static PagingPredicateHolder BuildHolder(ISerializationService serializationService,
PagingPredicate pagingPredicate, IData partitionKeyData)
{
var anchorList = pagingPredicate.AnchorList;
var anchorDataList = new List <KeyValuePair <IData, IData> >(anchorList.Count);
var pageList = new List <int>(anchorList.Count);
foreach (var pair in anchorList)
{
pageList.Add(pair.Key);
var anchorEntry = pair.Value;
anchorDataList.Add(new KeyValuePair <IData, IData>(serializationService.ToData(anchorEntry.Key),
serializationService.ToData(anchorEntry.Value)));
}
var anchorDataListHolder = new AnchorDataListHolder(pageList, anchorDataList);
var predicateData = serializationService.ToData(pagingPredicate.Predicate);
var comparatorData = serializationService.ToData(pagingPredicate.Comparer);
if (!pagingPredicate.IterationType.HasValue)
{
throw new InvalidOperationException("The paging predicate does not specify an iteration type.");
}
return(new PagingPredicateHolder(anchorDataListHolder, predicateData, comparatorData, pagingPredicate.PageSize,
pagingPredicate.Page, (byte)pagingPredicate.IterationType, partitionKeyData));
}
public RemoteUnitTestingApplicationService()
{
_silverlightUnitTestAbstractionsFactory =
SimpleServiceLocator.Instance.Get<ISilverlightUnitTestAbstractionsFactory>();
_serializationService = SimpleServiceLocator.Instance.Get<ISerializationService>();
}
public NetworkOperationWriter(OperationMap map, ISerializationService serializer, IOperationTransport transport)
{
_map = map;
_serializer = serializer;
_transport = transport;
}
private static void LoadServices(Assembly assembly)
{
var types = assembly.GetTypes();
TService GetType <TService>() where TService : class
{
var serviceType = types.FirstOrDefault(type => typeof(TService).IsAssignableFrom(type));
if (serviceType == null)
{
throw new Exception($"Unable to find service {nameof(TService)} in {assembly.FullName}");
}
var service = Activator.CreateInstance(serviceType) as TService;
if (service == null)
{
throw new Exception($"Unable to initialize service {serviceType.FullName}");
}
return(service);
}
_jobManager = GetType <IJobManager>();
_serializationService = GetType <ISerializationService>();
_legacyIndexingValidator = GetType <ILegacyIndexingValidator>();
}
internal ByteArrayObjectDataOutput(int size, ISerializationService service, ByteOrder byteOrder)
{
_initialSize = size;
_buffer = new byte[size];
_service = service;
_isBigEndian = byteOrder == ByteOrder.BigEndian;
}
/// <param name="cachingService">The caching service that backs the enumerable</param>
/// <param name="serializationService">The serialization service to use</param>
/// <param name="onlySerializeLogsOfTheCorrectType">Only serializes logs of the correct type, has a significant performance hit</param>
public TestCacheLogBaseEnumerable(ICachingService cachingService, ISerializationService serializationService, bool onlySerializeLogsOfTheCorrectType = false)
: base(null)
{
SerializationService = serializationService;
CachingService = cachingService;
OnlySerializeLogsOfTheCorrectType = onlySerializeLogsOfTheCorrectType;
}
public DefaultOpmlService(
ISerializationService serializationService,
ICategoryManager categoryManager)
{
_serializationService = serializationService;
_categoryManager = categoryManager;
}
public void TestCollection()
{
Base a = new Base();
Base b = new Base();
Base c = new Base();
Base d = new Base();
CollectionDerived e = new CollectionDerived()
{
Child = a, Parents = new List <Base>()
{
a, b, c, d
}
};
TypeConfiguration.TrustedTypes = TypeMatch.Assembly(typeof(SerializerTests).Assembly);
ISerializationService serializer = Container.Resolve <ISerializationService>();
string json = serializer.Serialize(e);
Console.WriteLine(json);
Base newE = serializer.Deserialize <Base>(json);
Assert.IsInstanceOfType(newE, typeof(CollectionDerived));
var listE = (CollectionDerived)newE;
Assert.IsNotNull(listE.Parents);
Assert.AreEqual(4, listE.Parents.Count());
Assert.AreEqual(listE.Child, listE.Parents.ElementAt(0));
}
/// <exception cref="System.IO.IOException" />
internal static void TestDifferentClassVersionsUsingDataWriteAndRead(ISerializationService serializationService,
ISerializationService serializationService2)
{
NamedPortable portableV1 = new NamedPortable("portable-v1", 111);
IData dataV1 = serializationService.ToData(portableV1);
// emulate socket write by writing data to stream
var @out = serializationService.CreateObjectDataOutput(1024);
@out.WriteData(dataV1);
var bytes = @out.ToByteArray();
// emulate socket read by reading data from stream
var @in = serializationService2.CreateObjectDataInput(bytes);
dataV1 = @in.ReadData();
// serialize new portable version
var portableV2 = new NamedPortableV2("portable-v2", 123, 500);
var dataV2 = serializationService2.ToData(portableV2);
NamedPortable v1FromV2 = serializationService.ToObject <NamedPortable>(dataV2);
Assert.AreEqual(portableV2.name, v1FromV2.name);
Assert.AreEqual(portableV2.k, v1FromV2.k);
NamedPortableV2 v2FromV1 = serializationService2.ToObject <NamedPortableV2>(dataV1);
Assert.AreEqual(portableV1.name, v2FromV1.name);
Assert.AreEqual(portableV1.k, v2FromV1.k);
Assert.AreEqual(v2FromV1.v, 0);
}
public GameDataRepository(IFileStorageService fileStorageService, IMapperFactory mapperFactory, ISerializationService serializationService, IUserSettingsService userSettingsService)
{
_fileStorageService = fileStorageService;
_mapperFactory = mapperFactory;
_serializationService = serializationService;
_userSettingsService = userSettingsService;
}
public OnOpened(
ISerializationService serialization,
IDataService data)
{
_serialization = serialization;
_data = data;
}
public virtual IEnumerable <RedisCachedObject <T> > SetValue <T>(RedisCachedObject <T> value)
{
if ((!(value?.Id?.HasFullKey ?? false)) || value.Value == null || value.Value.Equals(default(T)))
{
return(null);
}
string serializedWrapper;
string serializedObject;
ISerializationService sz =
RedisService.GetSerializationService <T>();
serializedObject = sz.SerializeObject <T>(value.Value, RedisService.CacheSettings.SerializationSettings);
RedisCachedObject <string> wrapper = new RedisCachedObject <string>
{
RetrievedSuccesfully = value.RetrievedSuccesfully,
Value = serializedObject,
CachedTime = value.CachedTime,
Status = value.Status,
Metadata = value.Metadata,
Id = value.Id,
ExpireTime = value.ExpireTime,
};
sz = RedisService.GetSerializationService <RedisCachedObject <string> >();
serializedWrapper = sz.SerializeObject <RedisCachedObject <string> >(wrapper, RedisService.CacheSettings.SerializationSettings);
HardAddToCache(value.Id, serializedWrapper, value.ExpireTime);
return(new[] { value });
}
public Form1()
{
InitializeComponent();
_steganographyService = IoC.Resolve<ISteganographyService>();
_serializationService = IoC.Resolve<ISerializationService>();
}
public ApplicationSettingsService(ISystemService systemService,
IFileSystemService fileSystemService,
ISerializationService serializationService)
{
_systemService = systemService;
_fileSystemService = fileSystemService;
_serializationService = serializationService;
}
public QueueActions( Uri queueUri, SqlConnection connection, ISerializationService serializationService = null )
: base(connection)
{
if ( queueUri == null )
throw new ArgumentNullException( "queueUri" );
this.queueUri = queueUri;
this.serializationService = serializationService ?? new DefaultSerializationService();
}
public OperationSystem(OperationMap map, ISerializationService serializer, IOperationTransport transport, Func<Type, IOperationHandler> handlerFactory)
{
var writer = new NetworkOperationWriter(map, serializer, transport);
var reader = new NetworkOperationReader(map, serializer);
var activeOperations = new ActiveOperationsManager();
Dispatcher = new OperationDispatcher(activeOperations, writer);
Processor = new OperationProcessor(new OperationService(activeOperations, writer, handlerFactory), reader);
}
internal ClientContext(ISerializationService serializationService, IClientClusterService clusterService,
IClientPartitionService partitionService, IClientInvocationService invocationService,
IClientExecutionService executionService, IClientListenerService listenerService, ProxyManager proxyManager, ClientConfig clientConfig)
{
this.serializationService = serializationService;
this.clusterService = clusterService;
this.partitionService = partitionService;
this.invocationService = invocationService;
this.executionService = executionService;
this.listenerService = listenerService;
this.proxyManager = proxyManager;
this.clientConfig = clientConfig;
}
internal ClientContext(ISerializationService serializationService, IClientClusterService clusterService,
IClientPartitionService partitionService, IClientInvocationService invocationService,
IClientExecutionService executionService, IClientListenerService listenerService, ProxyManager proxyManager,
ClientConfig clientConfig)
{
_serializationService = serializationService;
_clusterService = clusterService;
_partitionService = partitionService;
_invocationService = invocationService;
_executionService = executionService;
_listenerService = listenerService;
_proxyManager = proxyManager;
_clientConfig = clientConfig;
}
public MessageHandlingListener(Bus bus, IMessageNamingService namingService,
ISerializationService serializationService, IEnumerable<IMessageHandler> messageHandlers)
{
if (bus == null) throw new ArgumentNullException("bus");
if (namingService == null) throw new ArgumentNullException("namingService");
if (serializationService == null) throw new ArgumentNullException("serializationService");
if (messageHandlers == null) throw new ArgumentNullException("messageHandlers");
var handlerList = messageHandlers.Where(h => h != null).ToList();
if (!handlerList.Any()) throw new ArgumentNullException("messageHandlers");
_bus = bus;
_messageNamingService = namingService;
_serializationService = serializationService;
_messageHandlers = handlerList;
}
public static async Task HandleMessage(IMessageNamingService messageNamingService,
ISerializationService serializationService, IEnumerable<IMessageHandler> messageHandlers, Message message,
IMessageContext messageContext, CancellationToken cancellationToken = default(CancellationToken))
{
if (message.Headers.Expires < DateTime.UtcNow)
{
Log.WarnFormat("Discarding expired \"{0}\" message (ID {1}, expired {2})", message.Headers.MessageName,
message.Headers.MessageId, message.Headers.Expires);
messageContext.Acknowledge();
return;
}
var messageType = messageNamingService.GetTypeForName(message.Headers.MessageName);
var serializer = serializationService.GetSerializer(message.Headers.ContentType);
var messageContent = serializer.Deserialize(message.Content, messageType);
var handlingTasks =
messageHandlers.Select(
handler => handler.HandleMessage(messageContent, messageContext, cancellationToken));
await Task.WhenAll(handlingTasks);
}
public MainRegionViewModel(IEventAggregator eventAggregator,
IResourceDictionaryProvider resourceDictionaryProvider,
IApplicationProperties appliationProperties,
IEventContext eventContext,
IObjectServiceOperations objectServiceOperations,
IInteractionService interactionService,
IHistoricalTimeUtility historicalTimeUtility,
IPropertyNameService columnNameService,
IHistoricalColumnService historicalColumnService,
ISerializationService serializationService,
IHelpExtension helpExtension,
IValueFormatter valueFormatter,
IHdaFileExportService hdaFileExportService,
IDocumentationService documentationService)
: base(eventContext, objectServiceOperations,
interactionService, historicalTimeUtility,
columnNameService, historicalColumnService,
serializationService, helpExtension,
valueFormatter, eventAggregator,
hdaFileExportService, documentationService)
{
_eventAggregator = eventAggregator;
_eventContext = eventContext;
_historicalTimeUtility = historicalTimeUtility;
if (HistoricalExcelService.Current == null)
HistoricalExcelService.Current = new HistoricalExcelService(this,
eventContext, objectServiceOperations, interactionService, historicalTimeUtility, valueFormatter, appliationProperties);
ItemsHistoricalTimePeriodViewModel.Items.CollectionChanged += Items_CollectionChanged;
ListViewModel.ExportCommand = new DelegateCommand(ExportPropertyList);
ListViewModel.ExportCommandText = interactionService.TranslatingService.GetSystemText("Import");
EventListViewModel.ExportCommand = new DelegateCommand(ExportEventList);
EventListViewModel.ExportCommandText = interactionService.TranslatingService.GetSystemText("Import");
SubscribeEvents();
}
/// <summary>
/// Initializes a new <see cref="Bus"/> with the specified configuration and services
/// provided by the host
/// </summary>
/// <param name="configuration">The core bus configuration</param>
/// <param name="baseUri">The base URI provided by the host</param>
/// <param name="transportService">The transport service provided by the host</param>
/// <param name="messageQueueingService">The message queueing service provided by the host</param>
/// <exception cref="ArgumentNullException">Thrown if any of the parameters are <c>null</c></exception>
public Bus(IPlatibusConfiguration configuration, Uri baseUri, ITransportService transportService, IMessageQueueingService messageQueueingService)
{
if (configuration == null) throw new ArgumentNullException("configuration");
if (baseUri == null) throw new ArgumentNullException("baseUri");
if (transportService == null) throw new ArgumentNullException("transportService");
if (messageQueueingService == null) throw new ArgumentNullException("messageQueueingService");
_baseUri = baseUri;
_transportService = transportService;
_messageQueueingService = messageQueueingService;
// TODO: Throw configuration exception if message queueing service, message naming
// service, or serialization service are null
_messageJournalingService = configuration.MessageJournalingService;
_messageNamingService = configuration.MessageNamingService;
_serializationService = configuration.SerializationService;
_endpoints = new ReadOnlyEndpointCollection(configuration.Endpoints);
_topics = configuration.Topics.ToList();
_sendRules = configuration.SendRules.ToList();
_handlingRules = configuration.HandlingRules.ToList();
_subscriptions = configuration.Subscriptions.ToList();
}
private static void AssertRepeatedSerialisationGivesSameByteArrays(ISerializationService ss, IPortable p)
{
var data1 = ss.ToData(p);
for (var k = 0; k < 100; k++)
{
var data2 = ss.ToData(p);
Assert.AreEqual(data1, data2);
}
}
public RemoteUnitTestingApplicationService(ISerializationService serializationService, ISilverlightUnitTestAbstractionsFactory silverlightUnitTestAbstractionsFactory)
{
_serializationService = serializationService;
_silverlightUnitTestAbstractionsFactory = silverlightUnitTestAbstractionsFactory;
}
public TestResultsInformer(ISerializationService serializationService)
{
_serializationService = serializationService;
}
public virtual void Setup()
{
_serializationService = new SerializationServiceBuilder().Build();
}
public NetworkOperationReader(OperationMap map, ISerializationService serializer)
{
_map = map;
_serializer = serializer;
}
public IBufferObjectDataInput CreateInput(byte[] buffer, ISerializationService service)
{
return new ByteArrayObjectDataInput(buffer, service, _byteOrder);
}
internal static void TestDifferentClassVersions(ISerializationService serializationService,
ISerializationService serializationService2)
{
var p1 = new NamedPortable("named-portable", 123);
var data = serializationService.ToData(p1);
var p2 = new NamedPortableV2("named-portable", 123);
var data2 = serializationService2.ToData(p2);
var o1 = serializationService2.ToObject<NamedPortableV2>(data);
var o2 = serializationService.ToObject<NamedPortable>(data2);
Assert.AreEqual(o1.name, o2.name);
}
internal static void TestPreDefinedDifferentVersions(ISerializationService serializationService,
ISerializationService serializationService2, MainPortable mainPortable)
{
var data = serializationService.ToData(mainPortable);
Assert.AreEqual(mainPortable, serializationService2.ToObject<MainPortable>(data));
}
public HomeController(ISteganographyService steganographyService, ISerializationService serializationService)
{
_steganographyService = steganographyService;
_serializationService = serializationService;
}
public IBufferObjectDataInput CreateInput(IData data, ISerializationService service)
{
return new ByteArrayObjectDataInput(data.ToByteArray(), HeapData.DataOffset, service, _byteOrder);
}
public FileStorageService(ISerializationService serializationService)
{
_serializationService = serializationService;
}
/// <summary>
/// Initializes a new instance of the <see cref="ChatAppApiMiddleware"/> class.
/// </summary>
/// <param name="next">The next.</param>
/// <param name="messageProcessor">The message processor.</param>
/// <param name="serializationService">The serializationService.</param>
public ChatAppApiMiddleware(Func<IDictionary<string, object>, Task> next, IMessageProcessor messageProcessor, ISerializationService serializationService)
{
this.next = next;
this.messageProcessor = messageProcessor;
this.serializationService = serializationService;
}
public IBufferObjectDataOutput CreateOutput(int size, ISerializationService service)
{
return new ByteArrayObjectDataOutput(size, service, _byteOrder);
}
/// <exception cref="System.IO.IOException" />
internal static void TestDifferentClassVersionsUsingDataWriteAndRead(ISerializationService serializationService,
ISerializationService serializationService2)
{
var p1 = new NamedPortable("portable-v1", 111);
var data = serializationService.ToData(p1);
// emulate socket write by writing data to stream
var @out = serializationService.CreateObjectDataOutput(1024);
@out.WriteData(data);
var bytes = @out.ToByteArray();
// emulate socket read by reading data from stream
var @in = serializationService2.CreateObjectDataInput(bytes);
data = @in.ReadData();
// read data
var object1 = serializationService2.ToObject<object>(data);
// serialize new portable version
var p2 = new NamedPortableV2("portable-v2", 123);
var data2 = serializationService2.ToData(p2);
// de-serialize back using old version
var object2 = serializationService.ToObject<object>(data2);
Assert.IsNotNull(object1, "object1 should not be null!");
Assert.IsNotNull(object2, "object2 should not be null!");
Assert.IsInstanceOf<NamedPortableV2>(object1, "Should be instance of NamedPortableV2: " + object1.GetType());
Assert.IsInstanceOf<NamedPortable>(object2, "Should be instance of NamedPortable: " + object2.GetType());
}
/// <summary>
/// Initializes a new instance of the <see cref="CookieTempDataProvider"/> class.
/// </summary>
/// <param name="serializationService">
/// The serialization service.
/// </param>
/// <param name="dataCompressionService">
/// The data Compression Service.
/// </param>
/// <param name="machineKeyEncryptionService">
/// The machine Key Encryption Service.
/// </param>
public CookieTempDataProvider(
ISerializationService serializationService,
IDataCompressionService dataCompressionService,
IMachineKeyEncryptionService machineKeyEncryptionService)
{
if (serializationService == null)
{
throw new ArgumentNullException("serializationService");
}
if (dataCompressionService == null)
{
throw new ArgumentNullException("dataCompressionService");
}
if (machineKeyEncryptionService == null)
{
throw new ArgumentNullException("machineKeyEncryptionService");
}
this.serializationService = serializationService;
this.dataCompressionService = dataCompressionService;
this.machineKeyEncryptionService = machineKeyEncryptionService;
}
protected TestExecutor(IHtmlPageBuilder htmlPageBuilder, ISerializationService serializationService, ITestResultsInformer testResultsInformer, ILogger logger, ICleanupManager cleanupManager)
{
_htmlPageBuilder = htmlPageBuilder;
_serializationService = serializationService;
_testResultsInformer = testResultsInformer;
_logger = logger;
_cleanupManager = cleanupManager;
TestSessionId = Guid.NewGuid();
WorkDirectory = Path.GetTempPath();
if (!Directory.Exists(WorkDirectory))
{
Directory.CreateDirectory(WorkDirectory);
}
if (!Directory.Exists(CurrentTestSessionTempDirectory))
{
Directory.CreateDirectory(CurrentTestSessionTempDirectory);
}
_cleanupManager.DirectoriesToDelete.Add(CurrentTestSessionTempDirectory);
_testResultsInformer.TestsExecutionFinished += OnInformerFinished;
_testResultsInformer.TestsExecutionStarted += OnInformerStarted;
_testResultsInformer.SilverlightTestingClientReady += OnRemoteTestEnvironmentReady;
_testResultsInformer.TestingErrorOccured += OnInformerTestingErrorOccured;
_testResultsInformer.LogMessageSentFromTestingEnvironment += (s, e) =>
{
slideTheWatchdogTimer();
_logger.Log(e.Message);
};
_testResultsInformer.TestAssemblyStarted += (s, e) =>
{
slideTheWatchdogTimer();
_logger.Log(string.Format("Starting Assembly: {0}",
e.Assembly.Name));
};
_testResultsInformer.TestAssemblyFinished += (s, e) =>
{
slideTheWatchdogTimer();
_logger.Log(string.Format("Finished Assembly: {0}",
e.Assembly.Name));
};
_testResultsInformer.TestMethodStarted += (s, e) =>
{
slideTheWatchdogTimer();
_methodsStarted.Add(new TestMethodDetailedInformation() {Class = e.MethodDetailedInformation.Class, Method = e.MethodDetailedInformation.Method});
var msg = string.Format("[Started] {0}.{1}", e.MethodDetailedInformation.Class.Name, e.MethodDetailedInformation.Method.MethodName);
_logger.Log(msg);
};
_testResultsInformer.TestMethodFinished += (s, e) =>
{
slideTheWatchdogTimer();
_methodsFinished.Add(new TestMethodDetailedInformation() { Class = e.Result.TestClass, Method = e.Result.TestMethod});
TestExecutionResults.UnitTestOutcome.TestResults.Add(e.Result);
var msg = new StringBuilder(string.Format("{0}.{1} [{2}] ",e.Result.TestClass.Name, e.Result.TestMethod.MethodName, e.Result.Result.ToString()));
if (e.Result.Result != UnitTestOutcome.Passed && e.Result.Exception != null)
{
msg.AppendLine(e.Result.Exception.Message);
}
_logger.Log(msg.ToString());
};
_webBrowser = new WebBrowser
{
Dock = DockStyle.Fill,
ObjectForScripting = _testResultsInformer,
AllowNavigation = true,
ScriptErrorsSuppressed = true
};
_form = new Form
{
Text = "SilverlightUnitTestRunner",
Controls = { _webBrowser },
Visible = false,
WindowState = FormWindowState.Minimized,
ShowInTaskbar = false
};
}
public AuthenticationController(ISerializationService serializationService, IAuthLoginInfoRepository authLoginInfoRepository)
{
_serializationService = serializationService;
_authLoginInfoRepository = authLoginInfoRepository;
}
