public virtual void Before()
{
service1 = (SerializationService) new SerializationServiceBuilder()
.AddPortableFactory(TestSerializationConstants.PORTABLE_FACTORY_ID, new PortableFactoryFunc(
i => new MorphingBasePortable())).Build();
service2 = (SerializationService) new SerializationServiceBuilder()
.AddPortableFactory(TestSerializationConstants.PORTABLE_FACTORY_ID,
new PortableFactoryFunc(
i => new MorphingPortable())).Build();
var data = service1.ToData(new MorphingBasePortable(unchecked(1), true, (char) 2, 3, 4, 5, 1f, 2d, "test"));
var input = service2.CreateObjectDataInput(data);
var portableSerializer = service2.GetPortableSerializer();
reader = portableSerializer.CreateMorphingReader(input);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public FakeFrameworkContext(ISerializer serializer = null)
{
serializer = serializer ?? new ServiceStackSerialiser();
var fakeMapperList = new List<Lazy<AbstractMappingEngine, TypeMapperMetadata>>();
TypeMappers = new MappingEngineCollection(fakeMapperList);
CurrentLanguage = Thread.CurrentThread.CurrentCulture;
TextManager = LocalizationConfig.SetupDefault();
ScopedFinalizer = new NestedLifetimeFinalizer();
TaskManager = new ApplicationTaskManager(Enumerable.Empty<Lazy<AbstractTask, TaskMetadata>>());
ApplicationCache = new HttpRuntimeApplicationCache();
ScopedCache = new DictionaryScopedCache();
Caches = new DefaultFrameworkCaches(new DictionaryCacheProvider(), new RuntimeCacheProvider());
Serialization = new SerializationService(serializer);
}
/// <summary>
/// Initializes a new instance of the <see cref="Toolbox"/> class.
/// </summary>
public Toolbox()
{
#if !WPF
this.DefaultStyleKey = typeof(Toolbox);
#endif
#if WPF
this.Items.GroupDescriptions.CollectionChanged += this.GroupDescriptionsCollectionChanged;
#endif
this.serializator = new SerializationService(null);
this.ShowToolbox = new DelegateCommand(this.ExecuteShowToolbox, this.CanExecuteShowToolbox);
this.HideToolbox = new DelegateCommand(this.ExecuteHideToolbox);
this.InitializeDragAndDrop();
}
private async void DeserializeDataContractJsonClicked(object sender, RoutedEventArgs e)
{
var file = await StorageService.GetFileFromApplicationAsync("/Assets/Test/serialization.json");
var jsonString = await StorageService.ReadFile(file);
if (jsonString != null)
{
var start = DateTime.Now;
var data = SerializationService.DeserializeJson <IList <RootObject> >(jsonString);
var end = DateTime.Now;
Output.Text = string.Format("{0} ticks ({1} sec)\ndata-count: {2}", end.Ticks - start.Ticks, (end - start).TotalSeconds, data.Count);
}
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
var stylesheet = new Stylesheet("/css/styles.css");
stylesheet.Content = @"@media screen and (min-width: 600px) and (min-width: 900px) {
.class {
background: #666;
}
}";
var result = ss.ToStream(stylesheet);
var json = result.ResultStream.ToJsonString();
Debug.Print(json);
}
public async Task LoadAsync()
{
try
{
WorkingStart();
OutputService.WriteOutputWithContext("Start load Projectinformation.");
solutionPath = new FileInfo(service.Solution.FullName);
if (solutionPath?.DirectoryName != null)
{
var xmlFile = Path.Combine(solutionPath.DirectoryName,
solutionPath.Name.Replace(solutionPath.Extension, string.Empty));
Configuration = SerializationService.FromXml <ConfigData>($"{xmlFile}ConfigData.xml");
Data = SerializationService.FromXml <ObservableCollection <ProjectData> >($"{xmlFile}ProjectData.xml");
}
if (solutionPath.FullName.Contains("Dev-Feature"))
{
Configuration.IsFeature = true;
}
var task = Task.Run(() => Load());
await task;
var result = task.Result;
Data =
new ObservableCollection <ProjectData>(
Data.Concat(result.Select(item => item).Where(item => !Data.Contains(item))));
OutputService.WriteOutputWithContext("Finshed load Projectinformation.");
}
catch (Exception exception)
{
OutputService.WriteOutputWithContext($"Error: {exception.Message}");
logger.Error(exception, exception.Message);
}
finally
{
WorkingStop();
}
}
public void Can_Create_And_Serialize_Then_Deserialize_Macro()
{
// Arrange
var serviceStackSerializer = new ServiceStackJsonSerializer();
var serializationService = new SerializationService(serviceStackSerializer);
var macro = new Macro
{
Alias = "test",
CacheByPage = false,
CacheByMember = false,
DontRender = true,
Name = "Test",
Xslt = "/xslt/testMacro.xslt",
UseInEditor = false
};
macro.Properties = new List <IMacroProperty>();
macro.Properties.Add(new MacroProperty {
Alias = "level", Name = "Level", SortOrder = 0, PropertyType = new Umbraco.Core.Macros.PropertyTypes.Number()
});
macro.Properties.Add(new MacroProperty {
Alias = "fixedTitle", Name = "Fixed Title", SortOrder = 1, PropertyType = new Umbraco.Core.Macros.PropertyTypes.Text()
});
// Act
var json = serializationService.ToStream(macro);
string jsonString = json.ResultStream.ToJsonString();
var deserialized = serializationService.FromJson <Macro>(jsonString);
var stream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
object o = serializationService.FromStream(stream, typeof(Macro));
var deserialized2 = o as IMacro;
// Assert
Assert.That(json.Success, Is.True);
Assert.That(jsonString, Is.Not.Empty);
Assert.That(deserialized, Is.Not.Null);
Assert.That(deserialized2, Is.Not.Null);
Assert.That(deserialized.Name, Is.EqualTo(macro.Name));
Assert.That(deserialized.Alias, Is.EqualTo(macro.Alias));
Assert.That(deserialized2.Name, Is.EqualTo(macro.Name));
Assert.That(deserialized2.Alias, Is.EqualTo(macro.Alias));
}
public bool Run(params object[] args)
{
NWPlayer player = _.GetLastOpenedBy();
if (!player.IsPlayer)
{
return(false);
}
NWPlaceable terminal = Object.OBJECT_SELF;
NWArea area = terminal.Area;
int bankID = terminal.GetLocalInt("BANK_ID");
if (bankID <= 0)
{
Console.WriteLine("WARNING: Bank ID is not set on bank in area: " + area.Name);
return(false);
}
Data.Entity.Bank entity = DataService.SingleOrDefault <Data.Entity.Bank>(x => x.ID == bankID);
if (entity == null)
{
entity = new Data.Entity.Bank
{
AreaName = area.Name,
AreaResref = area.Resref,
AreaTag = area.Tag,
ID = bankID
};
DataService.SubmitDataChange(entity, DatabaseActionType.Insert);
}
var bankItems = DataService.Where <BankItem>(x => x.PlayerID == player.GlobalID && x.BankID == entity.ID);
foreach (BankItem item in bankItems.Where(x => x.PlayerID == player.GlobalID))
{
SerializationService.DeserializeItem(item.ItemObject, terminal);
}
terminal.IsLocked = true;
player.SendMessage("Walk away from the terminal when you are finished banking.");
return(true);
}
public static NodeElement ToNodeElement(CsvElement item)
{
NodeElement nodeElement = new NodeElement()
{
name = item.Name, label = item.Label, type = "element", meta = new NodeMeta()
{
description = item.Description, icon = new NodeIcon()
{
large = item.Icon, small = item.Icon
},
images = SerializationService.ToNodeImages(item.Images),
link = item.Link, list = item.List, multinational = true, sustainability = "", year = item.Year,
videos = SerializationService.ToNodeVideos(item.Videos)
}
};
return(nodeElement);
}
public override void TearDown()
{
base.TearDown();
//reset the app context
DataTypesResolver.Reset();
ApplicationContext.Current = null;
Resolution.IsFrozen = false;
PluginManager.Current = null;
string path = TestHelper.CurrentAssemblyDirectory;
AppDomain.CurrentDomain.SetData("DataDirectory", null);
SerializationService = null;
UmbracoSettings.ResetSetters();
}
private void SerializeDataContractJsonClicked(object sender, RoutedEventArgs e)
{
IList <RootObject> list = new List <RootObject>();
list.Add(GetObject("Jan", "Munich"));
list.Add(GetObject("Peter", "Munster"));
list.Add(GetObject("Karl", "Köln"));
list.Add(GetObject("Hugo", "Paris"));
list.Add(GetObject("Luis", "London"));
var start = DateTime.Now;
var data = SerializationService.SerializeJson(list);
var end = DateTime.Now;
Output.Text = string.Format("{0} ticks ({1} sec)", end.Ticks - start.Ticks, (end - start).TotalSeconds);
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
var item = new RelationType(Guid.NewGuid(), Guid.NewGuid(), "test")
{
Id = 66,
CreateDate = DateTime.Now,
IsBidirectional = true,
Key = Guid.NewGuid(),
Name = "Test",
UpdateDate = DateTime.Now
};
var result = ss.ToStream(item);
var json = result.ResultStream.ToJsonString();
Console.WriteLine(json);
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
var item = new TaskType("test")
{
Id = 3,
Alias = "test",
CreateDate = DateTime.Now,
Key = Guid.NewGuid(),
UpdateDate = DateTime.Now
};
var result = ss.ToStream(item);
var json = result.ResultStream.ToJsonString();
Console.WriteLine(json);
}
void FacadeNavigatedEventHandler(object sender, Windows.UI.Xaml.Navigation.NavigationEventArgs e)
{
DebugWrite();
CurrentPageType = e.SourcePageType;
CurrentPageParam = SerializationService.Deserialize(e.Parameter?.ToString());
var args = new NavigatedEventArgs(e, Content as Page);
if (NavigationModeHint != NavigationMode.New)
{
args.NavigationMode = NavigationModeHint;
}
NavigationModeHint = NavigationMode.New;
foreach (var handler in _navigatedEventHandlers)
{
handler(this, args);
}
}
protected internal NavigationService(Frame frame)
{
SerializationService = Services.SerializationService.SerializationService.Json;
IsInMainView = CoreApplication.MainView == CoreApplication.GetCurrentView();
FrameFacadeInternal = new FrameFacade(this, frame);
FrameFacadeInternal.Navigating += async(s, e) =>
{
if (e.Suspending)
{
return;
}
// allow the viewmodel to cancel navigation
e.Cancel = !(await NavigatingFromAsync(false, e.NavigationMode));
if (!e.Cancel)
{
await NavigateFromAsync(false);
}
};
FrameFacadeInternal.Navigated += async(s, e) =>
{
var parameter = SerializationService.Deserialize(e.Parameter?.ToString());
var currentContent = FrameFacadeInternal.Frame.Content;
if (Equals(e.Parameter?.ToString(), SerializationService.Serialize(LastNavigationParameter)))
{
parameter = LastNavigationParameter;
}
await this.GetDispatcherWrapper().DispatchAsync(async() =>
{
try
{
if (currentContent == FrameFacadeInternal.Frame.Content)
{
await NavigateToAsync(e.NavigationMode, parameter, FrameFacadeInternal.Frame.Content);
}
}
catch (Exception ex)
{
DebugWrite($"DispatchAsync/NavigateToAsync {ex.Message}");
throw;
}
}, 1);
};
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
var item = new UmbracoEntity()
{
Id = 3,
ContentTypeAlias = "test1",
CreatorId = 4,
Key = Guid.NewGuid(),
UpdateDate = DateTime.Now,
CreateDate = DateTime.Now,
Name = "Test",
ParentId = 5,
SortOrder = 6,
Path = "-1,23",
Level = 7,
ContentTypeIcon = "icon",
ContentTypeThumbnail = "thumb",
HasChildren = true,
HasPendingChanges = true,
IsDraft = true,
IsPublished = true,
NodeObjectTypeId = Guid.NewGuid()
};
item.AdditionalData.Add("test1", 3);
item.AdditionalData.Add("test2", "valuie");
item.AdditionalData.Add("test3", new UmbracoEntity.EntityProperty()
{
Value = "test",
PropertyEditorAlias = "TestPropertyEditor"
});
item.AdditionalData.Add("test4", new UmbracoEntity.EntityProperty()
{
Value = "test2",
PropertyEditorAlias = "TestPropertyEditor2"
});
var result = ss.ToStream(item);
var json = result.ResultStream.ToJsonString();
Console.WriteLine(json);
}
public void Main()
{
if (_.GetInventoryDisturbType() != DisturbType.Added)
{
return;
}
NWPlayer player = _.GetLastDisturbed();
NWPlaceable device = _.OBJECT_SELF;
NWItem item = _.GetInventoryDisturbItem();
// Check the item type to see if it's valid.
if (!IsValidItemType(item))
{
ItemService.ReturnItem(player, item);
player.SendMessage("You cannot reassemble this item.");
return;
}
// Only crafted items can be reassembled.
if (string.IsNullOrWhiteSpace(item.GetLocalString("CRAFTER_PLAYER_ID")))
{
ItemService.ReturnItem(player, item);
player.SendMessage("Only crafted items may be reassembled.");
return;
}
// DMs cannot reassemble because they don't have the necessary DB records.
if (player.IsDM)
{
ItemService.ReturnItem(player, item);
player.SendMessage("DMs cannot reassemble items at this time.");
return;
}
// Serialize the item into a string and store it into the temporary data for this player. Destroy the physical item.
var model = CraftService.GetPlayerCraftingData(player);
model.SerializedSalvageItem = SerializationService.Serialize(item);
item.Destroy();
// Start the Molecular Reassembly conversation.
DialogService.StartConversation(player, device, "MolecularReassembly");
}
public void Can_Read_And_Deserialize_Macro_From_Disc()
{
// Arrange
var serviceStackSerializer = new ServiceStackJsonSerializer();
var serializationService = new SerializationService(serviceStackSerializer);
var fileSystem = new PhysicalFileSystem("~/App_Data/Macros");
var macro = new Macro
{
Alias = "test",
CacheByPage = false,
CacheByMember = false,
DontRender = true,
Name = "Test",
Xslt = "/xslt/testMacro.xslt",
UseInEditor = false
};
macro.Properties = new List <IMacroProperty>();
macro.Properties.Add(new MacroProperty {
Alias = "level", Name = "Level", SortOrder = 0, PropertyType = new Umbraco.Core.Macros.PropertyTypes.Number()
});
macro.Properties.Add(new MacroProperty {
Alias = "fixedTitle", Name = "Fixed Title", SortOrder = 1, PropertyType = new Umbraco.Core.Macros.PropertyTypes.Text()
});
// Act
var json = serializationService.ToStream(macro);
string jsonString = json.ResultStream.ToJsonString();
fileSystem.AddFile("test-serialized-Macro.macro", json.ResultStream, true);
Stream stream = fileSystem.OpenFile("test-serialized-Macro.macro");
object o = serializationService.FromStream(stream, typeof(Macro));
var deserialized = o as IMacro;
// Assert
Assert.That(json.Success, Is.True);
Assert.That(jsonString, Is.Not.Empty);
Assert.That(fileSystem.FileExists("test-serialized-Macro.macro"), Is.True);
Assert.That(deserialized, Is.Not.Null);
Assert.That(deserialized.Name, Is.EqualTo(macro.Name));
Assert.That(deserialized.Alias, Is.EqualTo(macro.Alias));
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
var memberType = MockedContentTypes.CreateSimpleMemberType("memberType", "Member Type");
memberType.Id = 99;
var member = MockedMember.CreateSimpleMember(memberType, "Name", "*****@*****.**", "pass", "user", Guid.NewGuid());
var i = 200;
foreach (var property in member.Properties)
{
property.Id = ++i;
}
member.Id = 10;
member.CreateDate = DateTime.Now;
member.CreatorId = 22;
member.Comments = "comments";
member.Key = Guid.NewGuid();
member.FailedPasswordAttempts = 22;
member.Level = 3;
member.Path = "-1,4,10";
member.Groups = new[] { "group1", "group2" };
member.IsApproved = true;
member.IsLockedOut = true;
member.LastLockoutDate = DateTime.Now;
member.LastLoginDate = DateTime.Now;
member.LastPasswordChangeDate = DateTime.Now;
member.PasswordQuestion = "question";
member.ProviderUserKey = Guid.NewGuid();
member.RawPasswordAnswerValue = "raw answer";
member.RawPasswordValue = "raw pass";
member.SortOrder = 5;
member.Trashed = false;
member.UpdateDate = DateTime.Now;
member.Version = Guid.NewGuid();
((IUmbracoEntity)member).AdditionalData.Add("test1", 123);
((IUmbracoEntity)member).AdditionalData.Add("test2", "hello");
var result = ss.ToStream(member);
var json = result.ResultStream.ToJsonString();
Console.WriteLine(json);
}
private void CreatePlanungswocheCommandExecute()
{
if (!CanCreatePlanungswocheCommandExecute())
{
return;
}
var am = new ArbeitswochenService();
var aw = am.CreateArbeitswoche(Jahr, KalenderWoche);
var ms = new SerializationService();
aw.Mitarbeiter = new List <Common.Entities.Mitarbeiter>(ms.ReadMitarbeiterListe());
var vm = aw.MapArbeitswocheToViewmodel();
ArbeitswochenCollection.Add(vm);
SelectedArbeitswoche = vm;
ArbeitswocheVorschau.Refresh();
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
// Arrange
var contentType = MockedContentTypes.CreateTextpageContentType();
contentType.Id = 99;
var content = MockedContent.CreateTextpageContent(contentType, "Textpage", -1);
var i = 200;
foreach (var property in content.Properties)
{
property.Id = ++i;
}
content.Id = 10;
content.CreateDate = DateTime.Now;
content.CreatorId = 22;
content.ExpireDate = DateTime.Now;
content.Key = Guid.NewGuid();
content.Language = "en";
content.Level = 3;
content.Path = "-1,4,10";
content.ReleaseDate = DateTime.Now;
content.ChangePublishedState(PublishedState.Published);
content.SortOrder = 5;
content.Template = new Template("-1,2,3,4", "Test Template", "testTemplate")
{
Id = 88
};
content.Trashed = false;
content.UpdateDate = DateTime.Now;
content.Version = Guid.NewGuid();
content.WriterId = 23;
((IUmbracoEntity)content).AdditionalData.Add("test1", 123);
((IUmbracoEntity)content).AdditionalData.Add("test2", "hello");
var result = ss.ToStream(content);
var json = result.ResultStream.ToJsonString();
Debug.Print(json);
}
private volatile int _disposed; // disposed flag
/// <summary>
/// Initializes a new instance of the <see cref="Cluster"/> class.
/// </summary>
/// <param name="options">The cluster configuration.</param>
/// <param name="serializationService">The serialization service.</param>
/// <param name="loggerFactory">A logger factory.</param>
public Cluster(IClusterOptions options, SerializationService serializationService, ILoggerFactory loggerFactory)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (serializationService == null)
{
throw new ArgumentNullException(nameof(serializationService));
}
if (loggerFactory is null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
var clientName = string.IsNullOrWhiteSpace(options.ClientName)
? options.ClientNamePrefix + ClusterIdSequence.GetNext()
: options.ClientName;
var clusterName = string.IsNullOrWhiteSpace(options.ClusterName) ? "dev" : options.ClusterName;
State = new ClusterState(options, clusterName, clientName, new Partitioner(), loggerFactory);
State.ShutdownRequested += () =>
{
// yes, we are starting a fire-and-forget task
// but, DisposeAsync should never throw
// yet we add a CfAwaitNoThrow() for more safety
DisposeAsync().CfAwaitNoThrow();
};
// create components
_terminateConnections = new TerminateConnections(loggerFactory);
Members = new ClusterMembers(State, _terminateConnections);
Messaging = new ClusterMessaging(State, Members);
Events = new ClusterEvents(State, Messaging, _terminateConnections, Members);
Connections = new ClusterConnections(State, Members, serializationService);
_heartbeat = new Heartbeat(State, Messaging, options.Heartbeat, _terminateConnections);
// wire components
WireComponents();
HConsole.Configure(x => x.Configure <Cluster>().SetIndent(2).SetPrefix("CLUSTER"));
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
var item = new Language("en-AU")
{
CreateDate = DateTime.Now,
CultureName = "AU",
Id = 11,
IsoCode = "en",
Key = Guid.NewGuid(),
UpdateDate = DateTime.Now
};
var result = ss.ToStream(item);
var json = result.ResultStream.ToJsonString();
Console.WriteLine(json);
}
public void Setup()
{
_nhibernateTestSetup = new NhibernateTestSetupHelper();
var storageProvider = new IoHiveTestSetupHelper(_nhibernateTestSetup.FakeFrameworkContext);
Hive = new HiveManager(
new[]
{
new ProviderMappingGroup(
"test",
new WildcardUriMatch("content://"),
_nhibernateTestSetup.ReadonlyProviderSetup,
_nhibernateTestSetup.ProviderSetup,
_nhibernateTestSetup.FakeFrameworkContext),
storageProvider.CreateGroup("uploader", "storage://file-uploader"),
},
_nhibernateTestSetup.FakeFrameworkContext);
var appContext = new FakeRebelApplicationContext(Hive, false);
var resolverContext = new MockedMapResolverContext(_nhibernateTestSetup.FakeFrameworkContext, Hive, new MockedPropertyEditorFactory(appContext), new MockedParameterEditorFactory());
var webmModelMapper = new CmsModelMapper(resolverContext);
var renderModelMapper = new RenderTypesModelMapper(resolverContext);
_nhibernateTestSetup.FakeFrameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { webmModelMapper, renderModelMapper, new FrameworkModelMapper(_nhibernateTestSetup.FakeFrameworkContext) }));
var membersMembershipProvider = new MembersMembershipProvider {
AppContext = appContext
};
membersMembershipProvider.Initialize("MembersMembershipProvider", new NameValueCollection());
MembershipService = new MembershipService <Member, MemberProfile>(appContext.FrameworkContext, Hive,
"security://member-profiles", "security://member-groups", Framework.Security.Model.FixedHiveIds.MemberProfileVirtualRoot,
membersMembershipProvider, Enumerable.Empty <MembershipProviderElement>());
PublicAccessService = new PublicAccessService(Hive, MembershipService, appContext.FrameworkContext);
var serializer = new ServiceStackSerialiser();
SerializationService = new SerializationService(serializer);
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
var item = new Template("Test", "test")
{
Id = 3,
CreateDate = DateTime.Now,
Key = Guid.NewGuid(),
UpdateDate = DateTime.Now,
Content = "blah",
MasterTemplateAlias = "master",
MasterTemplateId = new Lazy <int>(() => 88)
};
var result = ss.ToStream(item);
var json = result.ResultStream.ToJsonString();
Debug.Print(json);
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
var item = new UserType()
{
Id = 3,
Key = Guid.NewGuid(),
UpdateDate = DateTime.Now,
CreateDate = DateTime.Now,
Name = "Test",
Alias = "test",
Permissions = new[] { "a", "b", "c" }
};
var result = ss.ToStream(item);
var json = result.ResultStream.ToJsonString();
Console.WriteLine(json);
}
public void AddSerializers(SerializationService service)
{
//TODO: proper support for generic types
service.AddConstantSerializer <JavaClass>(new JavaClassSerializer());
service.AddConstantSerializer <DateTime>(new DateSerializer());
service.AddConstantSerializer <BigInteger>(new BigIntegerSerializer());
service.AddConstantSerializer <object[]>(new ArrayStreamSerializer());
//TODO map server side collection types.
service.AddConstantSerializer <List <object> >(new ListSerializer <object>());
service.AddConstantSerializer <LinkedList <object> >(new LinkedListSerializer <object>());
service.AddConstantSerializer <Dictionary <object, object> >(new HashMapStreamSerializer());
service.AddConstantSerializer <ConcurrentDictionary <object, object> >(new ConcurrentHashMapStreamSerializer());
service.AddConstantSerializer <HashSet <object> >(new HashSetStreamSerializer());
service.AddConstantSerializer <HazelcastJsonValue>(new HazelcastJsonValueSerializer());
}
public async Task <bool> NavigateAsync(Type page, object parameter = null, NavigationTransitionInfo infoOverride = null)
{
DebugWrite($"Page: {page}, Parameter: {parameter}, NavigationTransitionInfo: {infoOverride}");
// serialize parameter
var serializedParameter = default(string);
try
{
serializedParameter = SerializationService.Serialize(parameter);
}
catch
{
throw new Exception("Parameter cannot be serialized. See https://github.com/Windows-XAML/Template10/wiki/Page-Parameters");
}
return(await NavigationOrchestratorAsync(page, parameter, NavigationMode.New, () =>
{
return FrameFacade.Navigate(page, serializedParameter, infoOverride);
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="HazelcastClient"/> class.
/// </summary>
/// <param name="options">The client configuration.</param>
/// <param name="cluster">A cluster.</param>
/// <param name="serializationService">A serialization service.</param>
/// <param name="loggerFactory">A logger factory.</param>
public HazelcastClient(HazelcastOptions options, Cluster cluster, SerializationService serializationService, ILoggerFactory loggerFactory)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
Cluster = cluster ?? throw new ArgumentNullException(nameof(cluster));
SerializationService = serializationService ?? throw new ArgumentNullException(nameof(serializationService));
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_logger = loggerFactory.CreateLogger <IHazelcastClient>();
_distributedOjects = new DistributedObjectFactory(Cluster, serializationService, loggerFactory);
_nearCacheManager = new NearCacheManager(cluster, serializationService, loggerFactory, options.NearCache);
if (options.Metrics.Enabled)
{
_metricsPublisher = new MetricsPublisher(cluster, options.Metrics, loggerFactory);
_metricsPublisher.AddSource(new ClientMetricSource(cluster, loggerFactory));
_metricsPublisher.AddSource(_nearCacheManager);
}
// wire components
WireComponents();
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
var item = new Relation(9, 8, new RelationType(Guid.NewGuid(), Guid.NewGuid(), "test")
{
Id = 66
})
{
Comment = "test comment",
CreateDate = DateTime.Now,
Id = 4,
Key = Guid.NewGuid(),
UpdateDate = DateTime.Now
};
var result = ss.ToStream(item);
var json = result.ResultStream.ToJsonString();
Debug.Print(json);
}
public void Can_Serialize_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
var item = new User(new UserType()
{
Id = 3
})
{
Id = 3,
Key = Guid.NewGuid(),
UpdateDate = DateTime.Now,
CreateDate = DateTime.Now,
Name = "Test",
Comments = "comments",
DefaultPermissions = new[] { "a", "b", "c" },
DefaultToLiveEditing = false,
Email = "*****@*****.**",
Language = "en",
FailedPasswordAttempts = 3,
IsApproved = true,
IsLockedOut = true,
LastLockoutDate = DateTime.Now,
LastLoginDate = DateTime.Now,
LastPasswordChangeDate = DateTime.Now,
//Password = "******",
//PasswordAnswer = "answer",
PasswordQuestion = "question",
//ProviderUserKey = "user key",
SessionTimeout = 5,
StartContentId = 3,
StartMediaId = 8,
Username = "******"
};
var result = ss.ToStream(item);
var json = result.ResultStream.ToJsonString();
Debug.Print(json);
}
public static async Task <APIGatewayProxyResponse> Run <TModule>(APIGatewayProxyRequest request, ILambdaContext context)
where TModule : Module, new()
{
var module = new TModule();
var serializationService = new SerializationService();
var builder = new LambdaModuleBuilder(module, serializationService);
builder.AddHandler <RequestHandler, RequestMessage>();
builder.AddHandler <SerializationHandler, SerializationMessage>();
module.Configure(builder);
module.Dependencies.AddSingleton(() => context);
module.Dependencies.AddSingleton(() => serializationService);
var handlerContext = new Context(module);
var responses = await handlerContext.Emit(new RequestMessage { Request = request });
return(responses.OfType <ResponseMessage>()
.FirstOrDefault()
?.Response);
}
private void OpenResourceBay()
{
NWPlaceable tower = (NWPlaceable)GetDialogTarget();
NWPlayer oPC = GetPC();
NWPlaceable bay = tower.GetLocalObject("CONTROL_TOWER_RESOURCE_BAY");
if (bay.IsValid)
{
NWObject accessor = bay.GetLocalObject("BAY_ACCESSOR");
if (!accessor.IsValid)
{
bay.Destroy();
}
else
{
oPC.FloatingText("Someone else is already accessing that structure's inventory. Please wait.");
return;
}
}
Guid structureID = new Guid(tower.GetLocalString("PC_BASE_STRUCTURE_ID"));
var structureItems = DataService.PCBaseStructureItem.GetAllByPCBaseStructureID(structureID);
Location location = oPC.Location;
bay = _.CreateObject(ObjectType.Placeable, "resource_bay", location);
tower.SetLocalObject("CONTROL_TOWER_RESOURCE_BAY", bay.Object);
bay.SetLocalObject("CONTROL_TOWER_PARENT", tower.Object);
bay.SetLocalString("PC_BASE_STRUCTURE_ID", structureID.ToString());
foreach (var item in structureItems)
{
SerializationService.DeserializeItem(item.ItemObject, bay);
}
oPC.AssignCommand(() => _.ActionInteractObject(bay.Object));
}
public void Setup()
{
_nhibernateTestSetup = new NhibernateTestSetupHelper();
var storageProvider = new IoHiveTestSetupHelper(_nhibernateTestSetup.FakeFrameworkContext);
Hive = new HiveManager(
new[]
{
new ProviderMappingGroup(
"test",
new WildcardUriMatch("content://"),
_nhibernateTestSetup.ReadonlyProviderSetup,
_nhibernateTestSetup.ProviderSetup,
_nhibernateTestSetup.FakeFrameworkContext),
storageProvider.CreateGroup("uploader", "storage://file-uploader"),
},
_nhibernateTestSetup.FakeFrameworkContext);
var appContext = new FakeUmbracoApplicationContext(Hive, false);
var resolverContext = new MockedMapResolverContext(_nhibernateTestSetup.FakeFrameworkContext, Hive, new MockedPropertyEditorFactory(appContext), new MockedParameterEditorFactory());
var webmModelMapper = new CmsModelMapper(resolverContext);
var renderModelMapper = new RenderTypesModelMapper(resolverContext);
_nhibernateTestSetup.FakeFrameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { webmModelMapper, renderModelMapper, new FrameworkModelMapper(_nhibernateTestSetup.FakeFrameworkContext) }));
var membersMembershipProvider = new MembersMembershipProvider { AppContext = appContext };
membersMembershipProvider.Initialize("MembersMembershipProvider", new NameValueCollection());
MembershipService = new MembershipService<Member, MemberProfile>(appContext.FrameworkContext, Hive,
"security://member-profiles", "security://member-groups", Framework.Security.Model.FixedHiveIds.MemberProfileVirtualRoot,
membersMembershipProvider, Enumerable.Empty<MembershipProviderElement>());
PublicAccessService = new PublicAccessService(Hive, MembershipService, appContext.FrameworkContext);
var serializer = new ServiceStackSerialiser();
SerializationService = new SerializationService(serializer);
}
private void OnDragInitialized(object sender, DragInitializeEventArgs args)
{
var toolBoxItem = args.OriginalSource as ToolboxItem;
if (toolBoxItem != null)
{
var serializer = new SerializationService(null);
var shape = toolBoxItem.Shape;
if (shape != null)
{
args.Data = serializer.SerializeItems(new List<IDiagramItem> { shape as IDiagramItem });
args.DragVisualOffset = new Point(args.RelativeStartPoint.X - (shape.ActualWidth / 2), args.RelativeStartPoint.Y - (shape.ActualHeight / 2));
var draggingImage = new Image
{
Source = new Telerik.Windows.Media.Imaging.RadBitmap(shape).Bitmap,
Width = shape.ActualWidth,
Height = shape.ActualHeight
};
args.DragVisual = draggingImage;
}
}
args.AllowedEffects = DragDropEffects.All;
args.Handled = true;
}
public ISerializationService Build()
{
if (_portableVersion < 0)
{
_portableVersion = 0;
}
if (_config != null)
{
AddConfigDataSerializableFactories(_dataSerializableFactories, _config);
AddConfigPortableFactories(_portableFactories, _config);
_classDefinitions = _classDefinitions.Union(_config.GetClassDefinitions()).ToList();
}
//TODO: add support for multiple versions
var ss = new SerializationService(
CreateInputOutputFactory(),
_portableVersion,
_dataSerializableFactories,
_portableFactories,
_classDefinitions,
_checkClassDefErrors,
_managedContext,
_partitioningStrategy,
_initialOutputBufferSize,
_enableCompression,
_enableSharedObject);
if (_config != null)
{
if (_config.GetGlobalSerializerConfig() != null)
{
var globalSerializerConfig = _config.GetGlobalSerializerConfig();
var serializer = globalSerializerConfig.GetImplementation();
if (serializer == null)
{
try
{
var className = globalSerializerConfig.GetClassName();
var type = Type.GetType(className);
if (type != null)
{
serializer = Activator.CreateInstance(type) as ISerializer;
}
}
catch (Exception e)
{
throw new HazelcastSerializationException(e);
}
}
var aware = serializer as IHazelcastInstanceAware;
if (aware != null)
{
aware.SetHazelcastInstance(_hazelcastInstance);
}
ss.RegisterGlobal(serializer, globalSerializerConfig.GetOverrideClrSerialization());
}
var typeSerializers = _config.GetSerializerConfigs();
foreach (var serializerConfig in typeSerializers)
{
var serializer = serializerConfig.GetImplementation();
if (serializer == null)
{
try
{
var className = serializerConfig.GetClassName();
var type = Type.GetType(className);
if (type != null)
{
serializer = Activator.CreateInstance(type) as ISerializer;
}
}
catch (Exception e)
{
throw new HazelcastSerializationException(e);
}
}
if (serializer is IHazelcastInstanceAware)
{
((IHazelcastInstanceAware) serializer).SetHazelcastInstance(_hazelcastInstance);
}
var typeClass = serializerConfig.GetTypeClass();
if (typeClass == null)
{
try
{
var className = serializerConfig.GetTypeClassName();
typeClass = Type.GetType(className);
}
catch (TypeLoadException e)
{
throw new HazelcastSerializationException(e);
}
}
ss.Register(typeClass, serializer);
}
}
return ss;
}
internal PortableContext(SerializationService serializationService, int version)
{
this._serializationService = serializationService;
this._version = version;
}
public ISerializationService Build()
{
if (_portableVersion < 0)
{
_portableVersion = 0;
}
if (_config != null)
{
AddConfigDataSerializableFactories(_dataSerializableFactories, _config);
AddConfigPortableFactories(_portableFactories, _config);
classDefinitions = classDefinitions.Union(_config.GetClassDefinitions()).ToList();
}
//TODO: add support for multiple versions
var ss = new SerializationService(
CreateInputOutputFactory(),
_portableVersion,
_dataSerializableFactories,
_portableFactories,
classDefinitions,
_checkClassDefErrors,
_managedContext,
_partitioningStrategy,
_initialOutputBufferSize,
_enableCompression,
_enableSharedObject);
if (_config != null)
{
if (_config.GetGlobalSerializerConfig() != null)
{
GlobalSerializerConfig globalSerializerConfig = _config.GetGlobalSerializerConfig();
ISerializer serializer = globalSerializerConfig.GetImplementation();
if (serializer == null)
{
try
{
string className = globalSerializerConfig.GetClassName();
Type type = Type.GetType(className);
if (type != null)
{
serializer = Activator.CreateInstance(type) as ISerializer;
}
}
catch (Exception e)
{
throw new HazelcastSerializationException(e);
}
}
var aware = serializer as IHazelcastInstanceAware;
if (aware != null)
{
aware.SetHazelcastInstance(_hazelcastInstance);
}
ss.RegisterGlobal(serializer);
}
ICollection<SerializerConfig> typeSerializers = _config.GetSerializerConfigs();
foreach (SerializerConfig serializerConfig in typeSerializers)
{
ISerializer serializer = serializerConfig.GetImplementation();
if (serializer == null)
{
try
{
string className = serializerConfig.GetClassName();
Type type = Type.GetType(className);
if (type != null)
{
serializer = Activator.CreateInstance(type) as ISerializer;
}
}
catch (Exception e)
{
throw new HazelcastSerializationException(e);
}
}
if (serializer is IHazelcastInstanceAware)
{
((IHazelcastInstanceAware)serializer).SetHazelcastInstance(_hazelcastInstance);
}
Type typeClass = serializerConfig.GetTypeClass();
if (typeClass == null)
{
try
{
string className = serializerConfig.GetTypeClassName();
typeClass = Type.GetType(className);
}
catch (TypeLoadException e)
{
throw new HazelcastSerializationException(e);
}
}
////call by reflaction
//MethodInfo method = typeof(ISerializationService).GetMethod("Register");
//MethodInfo generic = method.MakeGenericMethod(typeClass);
//generic.Invoke(ss, new object[] { serializer });
////mimics: ss.Register<typeClass>(serializer);"
ss.Register(typeClass, serializer);
}
}
return ss;
}
public override void SetUp()
{
var serializer = new JsonNetSerializer();
SerializationService = new SerializationService(serializer);
}
public override void SetUp()
{
var serializer = new ServiceStackSerialiser();
SerializationService = new SerializationService(serializer);
}
