static MsgPackSerializer()
{
CompositeResolver.RegisterAndSetAsDefault(
ActorPathResolver.Instance,
OldSpecResolver.Instance, // Redis compatible MsgPack spec
ContractlessStandardResolver.Instance);
}
public void Generics()
{
{
var x = FixtureFactory.Create <KeyValuePair <string, int> >();
var y = FixtureFactory.Create <KeyValuePair <string, int> >();
x.Key.Should().NotBe(y.Key);
x.Value.Should().NotBe(y.Value);
}
{
// type hint for IL2CPP
_ = new LazyGenerator.ValueGenerator <int>(0);
_ = new Lazy <int>(() => 0);
var x = FixtureFactory.Create <Lazy <int> >();
var y = FixtureFactory.Create <Lazy <int> >();
x.Value.Should().NotBe(y.Value);
}
{
var x = FixtureFactory.Create <Task <int> >();
var y = FixtureFactory.Create <Task <int> >();
x.Result.Should().NotBe(y.Result);
}
var resolver = new CompositeResolver(new[] {
new JapaneseHiraganaGenerator(stringLength: 9),
}, new[] {
StandardResolver.NonNull
});
}
/// <summary>
/// Initializes a new instance of the <see cref="MessagePackHubProtocol"/> class.
/// </summary>
/// <param name="options">The options used to initialize the protocol.</param>
public MessagePackHubProtocol(IOptions <MessagePackHubProtocolOptions> options)
{
var msgPackOptions = options.Value;
var resolver = SignalRResolver.Instance;
var hasCustomFormatterResolver = false;
// if counts don't match then we know users customized resolvers so we set up the options with the provided resolvers
if (msgPackOptions.FormatterResolvers.Count != SignalRResolver.Resolvers.Count)
{
hasCustomFormatterResolver = true;
}
else
{
// Compare each "reference" in the FormatterResolvers IList<> against the default "SignalRResolver.Resolvers" IList<>
for (var i = 0; i < msgPackOptions.FormatterResolvers.Count; i++)
{
// check if the user customized the resolvers
if (msgPackOptions.FormatterResolvers[i] != SignalRResolver.Resolvers[i])
{
hasCustomFormatterResolver = true;
break;
}
}
}
if (hasCustomFormatterResolver)
{
resolver = CompositeResolver.Create(Array.Empty <IMessagePackFormatter>(), (IReadOnlyList <IFormatterResolver>)msgPackOptions.FormatterResolvers);
}
_msgPackSerializerOptions = MessagePackSerializerOptions.Standard
.WithResolver(resolver)
.WithSecurity(MessagePackSecurity.UntrustedData);
}
private static MessagePackSerializerOptions CreateMessagePackSerializerOptions()
{
var formatters = new IMessagePackFormatter[]
{
AlternatePackageMetadataContextInfoFormatter.Instance,
FloatRangeFormatter.Instance,
IPackageReferenceContextInfoFormatter.Instance,
IProjectContextInfoFormatter.Instance,
IProjectMetadataContextInfoFormatter.Instance,
NuGetFrameworkFormatter.Instance,
NuGetVersionFormatter.Instance,
PackageDependencyFormatter.Instance,
PackageDependencyGroupFormatter.Instance,
PackageDependencyInfoFormatter.Instance,
PackageDeprecationMetadataContextInfoFormatter.Instance,
PackageIdentityFormatter.Instance,
PackageReferenceFormatter.Instance,
PackageSearchMetadataContextInfoFormatter.Instance,
PackageSourceFormatter.Instance,
PackageSourceContextInfoFormatter.Instance,
PackageSourceUpdateOptionsFormatter.Instance,
PackageVulnerabilityMetadataContextInfoFormatter.Instance,
ProjectActionFormatter.Instance,
VersionRangeFormatter.Instance,
SearchFilterFormatter.Instance,
SearchResultContextInfoFormatter.Instance,
VersionInfoContextInfoFormatter.Instance,
};
var resolvers = new IFormatterResolver[] { MessagePack.MessagePackSerializerOptions.Standard.Resolver };
return(MessagePack.MessagePackSerializerOptions.Standard
.WithSecurity(MessagePackSecurity.UntrustedData)
.WithResolver(CompositeResolver.Create(formatters, resolvers)));
}
private static IServiceProvider BuildServiceProvider()
{
// Register the MessagePack resolvers
// TODO: should this be here?
CompositeResolver.RegisterAndSetAsDefault(
CoreLibrary.Generated.Resolvers.CoreLibraryGeneratedResolver.Instance,
DRXLibrary.Generated.Resolvers.DRXLibraryGeneratedResolver.Instance,
BuiltinResolver.Instance,
AttributeFormatterResolver.Instance,
PrimitiveObjectResolver.Instance
);
var collection = new ServiceCollection();
collection.AddLogging();
collection.AddSingleton(typeof(StoreService));
collection.AddSingleton(typeof(UserService));
_serviceProvider = collection.BuildServiceProvider();
var factory = _serviceProvider.GetService <ILoggerFactory>();
factory.AddFile($"{ApplicationData.Current.LocalFolder.Path}\\logs\\app.log");
App.RegisterCrashLogger(factory.CreateLogger("ExceptionHandler"));
return(_serviceProvider);
}
public IEnumerable <ValidationError> Validate(ValidationParameters validationParameters)
{
var resolver = new CompositeResolver(EnvironmentResolver.Instance, EngineResolver.Instance); // TODO: use specified resolver.
foreach (var benchmark in validationParameters.Benchmarks)
{
var run = benchmark.Job.Run;
int unrollFactor = run.ResolveValue(RunMode.UnrollFactorCharacteristic, resolver);
if (unrollFactor <= 0)
{
yield return(new ValidationError(true, $"Specified UnrollFactor ({unrollFactor}) must be greater than zero", benchmark));
}
else if (run.HasValue(RunMode.InvocationCountCharacteristic))
{
int invocationCount = run.InvocationCount;
if (invocationCount % unrollFactor != 0)
{
string message = $"Specified InvocationCount ({invocationCount}) must be a multiple of UnrollFactor ({unrollFactor})";
yield return(new ValidationError(true, message, benchmark));
}
}
foreach (var validationError in ValidateMinMax(run, resolver, benchmark, RunMode.MinIterationCountCharacteristic, RunMode.MaxIterationCountCharacteristic))
{
yield return(validationError);
}
foreach (var validationError in ValidateMinMax(run, resolver, benchmark, RunMode.MinWarmupIterationCountCharacteristic, RunMode.MaxWarmupIterationCountCharacteristic))
{
yield return(validationError);
}
}
}
static void Main(string[] args)
{
CompositeResolver.RegisterAndSetAsDefault(new[]
{
EnumResolver.UnderlyingValue,
StandardResolver.ExcludeNullCamelCase
});
// Get the message handler
IMessageHandler messageHandler = ServiceProvider.GetService <IMessageHandler>();
IMessageHandlerCallback messageHandlerCallback = ServiceProvider.GetService <IMessageHandlerCallback>();
try
{
Console.WriteLine("Starting handler");
messageHandler.Start(messageHandlerCallback);
Console.WriteLine("Handler started");
}
catch (Exception ex)
{
// Error during staring
Console.Error.WriteLine($"Error during starting message handler, message: {ex.Message}");
Environment.Exit(1);
}
Console.WriteLine("Security service started.");
while (true)
{
Thread.Sleep(10000);
}
}
internal Engine(
IHost host,
Action dummy1Action, Action dummy2Action, Action dummy3Action, Action <long> idleAction, Action <long> mainAction, Job targetJob,
Action globalSetupAction, Action globalCleanupAction, Action iterationSetupAction, Action iterationCleanupAction, long operationsPerInvoke,
bool includeMemoryStats)
{
Host = host;
IdleAction = idleAction;
Dummy1Action = dummy1Action;
Dummy2Action = dummy2Action;
Dummy3Action = dummy3Action;
MainAction = mainAction;
TargetJob = targetJob;
GlobalSetupAction = globalSetupAction;
GlobalCleanupAction = globalCleanupAction;
IterationSetupAction = iterationSetupAction;
IterationCleanupAction = iterationCleanupAction;
OperationsPerInvoke = operationsPerInvoke;
this.includeMemoryStats = includeMemoryStats;
Resolver = new CompositeResolver(BenchmarkRunner.DefaultResolver, EngineResolver.Instance);
Clock = targetJob.ResolveValue(InfrastructureMode.ClockCharacteristic, Resolver);
ForceAllocations = targetJob.ResolveValue(GcMode.ForceCharacteristic, Resolver);
UnrollFactor = targetJob.ResolveValue(RunMode.UnrollFactorCharacteristic, Resolver);
Strategy = targetJob.ResolveValue(RunMode.RunStrategyCharacteristic, Resolver);
EvaluateOverhead = targetJob.ResolveValue(AccuracyMode.EvaluateOverheadCharacteristic, Resolver);
InvocationCount = targetJob.ResolveValue(RunMode.InvocationCountCharacteristic, Resolver);
warmupStage = new EngineWarmupStage(this);
pilotStage = new EnginePilotStage(this);
targetStage = new EngineTargetStage(this);
}
private static void BuildMasterData()
{
try {
CompositeResolver.RegisterAndSetAsDefault(new [] {
MasterMemoryResolver.Instance,
GeneratedResolver.Instance,
StandardResolver.Instance
});
} catch { }
var builder = new DatabaseBuilder();
builder = BuildParson(builder);
builder = BuildSkill(builder);
builder = BuildSkillParameter(builder);
byte[] data = builder.Build();
var resourcesDir = $"{Application.dataPath}/Resources";
Directory.CreateDirectory(resourcesDir);
var filename = "/master-data.bytes";
using (var fs = new FileStream(resourcesDir + filename, FileMode.Create)) {
fs.Write(data, 0, data.Length);
}
Debug.Log($"Write byte[] to: {resourcesDir + filename}");
AssetDatabase.Refresh();
}
static UserData()
{
CompositeResolver.RegisterAndSetAsDefault(
ImmutableCollectionResolver.Instance,
StandardResolverAllowPrivate.Instance
);
}
private static (bool favorite, string timePlayed, string lastPlayed) GetMetadata(string titleId)
{
string metadataFolder = Path.Combine(new VirtualFileSystem().GetBasePath(), "games", titleId, "gui");
string metadataFile = Path.Combine(metadataFolder, "metadata.json");
IJsonFormatterResolver resolver = CompositeResolver.Create(StandardResolver.AllowPrivateSnakeCase);
if (!File.Exists(metadataFile))
{
Directory.CreateDirectory(metadataFolder);
_appMetadata = new ApplicationMetadata
{
Favorite = false,
TimePlayed = 0,
LastPlayed = "Never"
};
byte[] saveData = JsonSerializer.Serialize(_appMetadata, resolver);
File.WriteAllText(metadataFile, Encoding.UTF8.GetString(saveData, 0, saveData.Length).PrettyPrintJson());
}
using (Stream stream = File.OpenRead(metadataFile))
{
_appMetadata = JsonSerializer.Deserialize <ApplicationMetadata>(stream, resolver);
}
return(_appMetadata.Favorite, ConvertSecondsToReadableString(_appMetadata.TimePlayed), _appMetadata.LastPlayed);
}
public DeserilaizationBenchmark()
{
//JSON.NET Setup
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Converters = new List <JsonConverter>
{
new DateJsonSerializer()
}
};
_jsonInput = File.ReadAllText(@"Serialization\MonthlyFeeEvent.json");
_bsonInput = File.ReadAllBytes(@"Serialization\MonthlyFeeEvent.bson");
//MsgPack.Cli setup
var context = new SerializationContext();
context.Serializers.Register(new DateMsgPackSerializer(context));
context.SerializationMethod = SerializationMethod.Map;
_msgPackserializer = context.GetSerializer <MonthlyFeeChargedEvent>(context);
_msgPackProxySerializer = context.GetSerializer <MonthlyFeeChargedEventProxy>(context);
_fullMsgPackInput = File.ReadAllBytes(@"Serialization\MonthlyFeeEvent.msgpack");
//MessagePack-CS set up
CompositeResolver.RegisterAndSetAsDefault(
CustomCompositeResolver.Instance,
ContractlessStandardResolver.Instance
);
_csPayload = File.ReadAllBytes(@"Serialization\MonthlyFeeEvent.MessagePack");
_lz4CsPayload = File.ReadAllBytes(@"Serialization\MonthlyFeeEvent.MessagePack.lz4");
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
CompositeResolver.RegisterAndSetAsDefault(new[]
{
EnumResolver.UnderlyingValue,
StandardResolver.ExcludeNullCamelCase
});
Persistence.Extensions.DIHelper.OnServicesSetup(app.ApplicationServices);
//Seed initial shipservices
var shipServiceManager = app.ApplicationServices.GetService <IShipServiceManager>();
if (shipServiceManager.GetShipServicesCount().GetAwaiter().GetResult() == 0)
{
SeedHelper.Seed(shipServiceManager).GetAwaiter().GetResult();
}
app.UseMvc();
}
public void ActualOptions_IsOrDerivesFrom_SetMessagePackSerializerOptions()
{
var customFormatter = new CustomFormatter();
var options = (CustomOptions) new CustomOptions(MessagePackFormatter.DefaultUserDataSerializationOptions)
{
CustomProperty = 3
}
.WithResolver(CompositeResolver.Create(customFormatter));
this.formatter.SetMessagePackSerializerOptions(options);
var value = new JsonRpcRequest
{
RequestId = new RequestId(1),
Method = "Eat",
ArgumentsList = new object[] { new TypeRequiringCustomFormatter() },
};
var sequence = new Sequence <byte>();
this.formatter.Serialize(sequence, value);
var observedOptions = Assert.IsType <CustomOptions>(customFormatter.LastObservedOptions);
Assert.Equal(options.CustomProperty, observedOptions.CustomProperty);
}
private void SetupResolver(MessagePackHubProtocolOptions options)
{
// if counts don't match then we know users customized resolvers so we set up the options
// with the provided resolvers
if (options.FormatterResolvers.Count != SignalRResolver.Resolvers.Count)
{
var resolver = CompositeResolver.Create(Array.Empty <IMessagePackFormatter>(), (IReadOnlyList <IFormatterResolver>)options.FormatterResolvers);
_msgPackSerializerOptions = MessagePackSerializerOptions.Standard.WithResolver(resolver);
return;
}
for (var i = 0; i < options.FormatterResolvers.Count; i++)
{
// check if the user customized the resolvers
if (options.FormatterResolvers[i] != SignalRResolver.Resolvers[i])
{
var resolver = CompositeResolver.Create(Array.Empty <IMessagePackFormatter>(), (IReadOnlyList <IFormatterResolver>)options.FormatterResolvers);
_msgPackSerializerOptions = MessagePackSerializerOptions.Standard.WithResolver(resolver);
return;
}
}
// Use optimized cached resolver if the default is chosen
_msgPackSerializerOptions = MessagePackSerializerOptions.Standard.WithResolver(SignalRResolver.Instance);
}
public ResultOfTTeMessagePackFormatterTests()
{
var resolver = CompositeResolver.Create(StandardResolver.Instance, CSharpFunctionalExtensionsFormatResolver.Instance);
_options = MessagePackSerializerOptions.Standard
.WithResolver(resolver);
}
private static MessagePackSerializerOptions CreateMessagePackSerializerOptions()
{
var formatters = new IMessagePackFormatter[]
{
FloatRangeFormatter.Instance,
IPackageReferenceContextInfoFormatter.Instance,
IProjectContextInfoFormatter.Instance,
IProjectMetadataContextInfoFormatter.Instance,
NuGetFrameworkFormatter.Instance,
NuGetVersionFormatter.Instance,
PackageDependencyFormatter.Instance,
PackageDependencyInfoFormatter.Instance,
PackageIdentityFormatter.Instance,
PackageReferenceFormatter.Instance,
PackageSourceFormatter.Instance,
PackageSourceUpdateOptionsFormatter.Instance,
ProjectActionFormatter.Instance,
RemoteErrorFormatter.Instance,
VersionRangeFormatter.Instance
};
var resolvers = new IFormatterResolver[] { MessagePack.MessagePackSerializerOptions.Standard.Resolver };
return(MessagePack.MessagePackSerializerOptions.Standard
.WithSecurity(MessagePackSecurity.UntrustedData)
.WithResolver(CompositeResolver.Create(formatters, resolvers)));
}
public override void InstallBindings()
{
var resolver = CompositeResolver.Create(GeneratedResolver.Instance, StandardResolver.Instance);
var options = MessagePackSerializerOptions.Standard.WithResolver(resolver);
MessagePackSerializer.DefaultOptions = options;
}
static EventsSerializer()
{
Options ??= MessagePackSerializerOptions.Standard.WithResolver(
CompositeResolver.Create(
UnityWebBrowserResolver.Instance,
StandardResolver.Instance));
}
public static async Task <int> Main(string[] args)
{
CompositeResolver.RegisterAndSetAsDefault(FSharpResolver.Instance, StandardResolver.Default);
try
{
await BatchHost
.CreateDefaultBuilder()
.UseServiceProviderFactory <IUnityContainer>(new ServiceProviderFactory(new UnityContainer()))
.ConfigureContainer <IUnityContainer>((hostContext, container) =>
{
container.RegisterInstance <IMessageBroker>(Reactive.Bindings.Notifiers.MessageBroker.Default);
container.RegisterInstance <IUnityContainer>(container);
container.RegisterType <ICommandBus, CommandBus>();
container.RegisterType <I発送本DTOQuery, 発送本DTOQuery>();
container.RegisterType <I本を発送するCommand, 本を発送するCommand>();
container.RegisterType <I本を発送するCommandHandler, 本を発送するCommandHandler>();
})
.RunBatchEngineAsync <Scenario>(args);
return(Environment.ExitCode);
}
catch (Exception ex) when((ex is ArgumentException) || (ex is ArgumentNullException))
{
Console.WriteLine(ex.Message);
return(1);
}
catch (Exception)
{
return(9);
}
}
public async Task PropertiesGetterOnlyMixed()
{
using var tempWorkarea = TemporaryProjectWorkarea.Create();
var contents = @"
using System;
using System.Collections.Generic;
using MessagePack;
namespace TempProject
{
[MessagePackObject(true)]
public class MyMessagePackObject
{
public int A { get; }
public string B { get; set; }
}
}
";
tempWorkarea.AddFileToTargetProject("MyMessagePackObject.cs", contents);
var compiler = new MessagePackCompiler.CodeGenerator(testOutputHelper.WriteLine, CancellationToken.None);
await compiler.GenerateFileAsync(
tempWorkarea.GetOutputCompilation().Compilation,
tempWorkarea.OutputDirectory,
"TempProjectResolver",
"TempProject.Generated",
false,
string.Empty,
Array.Empty <string>());
var compilation = tempWorkarea.GetOutputCompilation();
compilation.Compilation.GetDiagnostics().Should().NotContain(x => x.Severity == DiagnosticSeverity.Error);
// Run tests with the generated resolver/formatter assembly.
compilation.ExecuteWithGeneratedAssembly((ctx, assembly) =>
{
var mpoType = assembly.GetType("TempProject.MyMessagePackObject");
var options = MessagePackSerializerOptions.Standard
.WithResolver(CompositeResolver.Create(
StandardResolver.Instance,
TestUtilities.GetResolverInstance(assembly, "TempProject.Generated.Resolvers.TempProjectResolver")));
// Build `{ "A": -1, "B": "foobar" }`.
var seq = new Sequence <byte>();
var writer = new MessagePackWriter(seq);
writer.WriteMapHeader(2);
writer.Write("A");
writer.Write(-1);
writer.Write("B");
writer.Write("foobar");
writer.Flush();
// Verify deserialization
dynamic result = MessagePackSerializer.Deserialize(mpoType, seq, options);
((int)result.A).Should().Be(0); // default
((string)result.B).Should().Be("foobar"); // from input
});
}
private void FavToggle_Toggled(object sender, ToggledArgs args)
{
_tableStore.GetIter(out TreeIter treeIter, new TreePath(args.Path));
string titleId = _tableStore.GetValue(treeIter, 2).ToString().Split("\n")[1].ToLower();
string metadataPath = System.IO.Path.Combine(new VirtualFileSystem().GetBasePath(), "games", titleId, "gui", "metadata.json");
IJsonFormatterResolver resolver = CompositeResolver.Create(new[] { StandardResolver.AllowPrivateSnakeCase });
ApplicationMetadata appMetadata;
using (Stream stream = File.OpenRead(metadataPath))
{
appMetadata = JsonSerializer.Deserialize <ApplicationMetadata>(stream, resolver);
}
if ((bool)_tableStore.GetValue(treeIter, 0))
{
_tableStore.SetValue(treeIter, 0, false);
appMetadata.Favorite = false;
}
else
{
_tableStore.SetValue(treeIter, 0, true);
appMetadata.Favorite = true;
}
byte[] saveData = JsonSerializer.Serialize(appMetadata, resolver);
File.WriteAllText(metadataPath, Encoding.UTF8.GetString(saveData, 0, saveData.Length).PrettyPrintJson());
}
private AboutWindow(Builder builder) : base(builder.GetObject("_aboutWin").Handle)
{
builder.Autoconnect(this);
_aboutWin.Icon = new Gdk.Pixbuf(Assembly.GetExecutingAssembly(), "Ryujinx.Ui.assets.Icon.png");
_ryujinxLogo.Pixbuf = new Gdk.Pixbuf(Assembly.GetExecutingAssembly(), "Ryujinx.Ui.assets.Icon.png", 100, 100);
_patreonLogo.Pixbuf = new Gdk.Pixbuf(Assembly.GetExecutingAssembly(), "Ryujinx.Ui.assets.PatreonLogo.png", 30, 30);
_gitHubLogo.Pixbuf = new Gdk.Pixbuf(Assembly.GetExecutingAssembly(), "Ryujinx.Ui.assets.GitHubLogo.png", 30, 30);
_discordLogo.Pixbuf = new Gdk.Pixbuf(Assembly.GetExecutingAssembly(), "Ryujinx.Ui.assets.DiscordLogo.png", 30, 30);
_twitterLogo.Pixbuf = new Gdk.Pixbuf(Assembly.GetExecutingAssembly(), "Ryujinx.Ui.assets.TwitterLogo.png", 30, 30);
try
{
IJsonFormatterResolver resolver = CompositeResolver.Create(new[] { StandardResolver.AllowPrivateSnakeCase });
using (Stream stream = File.OpenRead(System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "RyuFS", "Installer", "Config", "Config.json")))
{
AboutInformation = JsonSerializer.Deserialize <AboutInfo>(stream, resolver);
}
_versionText.Text = $"Version {AboutInformation.InstallVersion} - {AboutInformation.InstallBranch} ({AboutInformation.InstallCommit})";
}
catch
{
_versionText.Text = "Unknown Version";
}
}
public void DataContractSerializerCompatibility()
{
var master = new Master
{
A = 1,
InternalComplexProperty = new Detail
{
B1 = 2,
B2 = 3,
},
InternalComplexField = new Detail
{
B1 = 4,
B2 = 5,
},
};
var dcsValue = DataContractSerializerRoundTrip(master);
var option = MessagePackSerializerOptions.Standard.WithResolver(CompositeResolver.Create(
DynamicObjectResolverAllowPrivate.Instance,
ContractlessStandardResolver.Instance));
var mpValue = MessagePackSerializer.Deserialize <Master>(MessagePackSerializer.Serialize(master, option), option);
Assert.Equal(dcsValue, mpValue);
}
public ProblemDetailsMessagePackFormatterTests()
{
var resolver = CompositeResolver.Create(StandardResolver.Instance, ProblemDetailsFormatResolver.Instance);
_options = MessagePackSerializerOptions.Standard
.WithResolver(resolver);
}
internal Engine(
IHost host,
Action dummy1Action, Action dummy2Action, Action dummy3Action, Action <long> idleAction, Action <long> mainAction, Job targetJob,
Action setupAction, Action cleanupAction, long operationsPerInvoke)
{
Host = host;
IsDiagnoserAttached = host.IsDiagnoserAttached;
IdleAction = idleAction;
Dummy1Action = dummy1Action;
Dummy2Action = dummy2Action;
Dummy3Action = dummy3Action;
MainAction = mainAction;
TargetJob = targetJob;
SetupAction = setupAction;
CleanupAction = cleanupAction;
OperationsPerInvoke = operationsPerInvoke;
Resolver = new CompositeResolver(BenchmarkRunnerCore.DefaultResolver, EngineResolver.Instance);
Clock = targetJob.ResolveValue(InfrastructureMode.ClockCharacteristic, Resolver);
ForceAllocations = targetJob.ResolveValue(GcMode.ForceCharacteristic, Resolver);
UnrollFactor = targetJob.ResolveValue(RunMode.UnrollFactorCharacteristic, Resolver);
Strategy = targetJob.ResolveValue(RunMode.RunStrategyCharacteristic, Resolver);
EvaluateOverhead = targetJob.ResolveValue(AccuracyMode.EvaluateOverheadCharacteristic, Resolver);
InvocationCount = targetJob.ResolveValue(RunMode.InvocationCountCharacteristic, Resolver);
warmupStage = new EngineWarmupStage(this);
pilotStage = new EnginePilotStage(this);
targetStage = new EngineTargetStage(this);
}
static void CheckUnsfeResolver()
{
UnsafeDirectBlitResolver.Register <Foo>();
CompositeResolver.RegisterAndSetAsDefault(
UnsafeDirectBlitResolver.Instance,
BuiltinResolver.Instance
);
var f = new Foo {
A = 10, B = 9999, C = 9999999
};
var doudarou = MessagePackSerializer.Serialize(f, UnsafeDirectBlitResolver.Instance);
var two = MessagePackSerializer.Deserialize <Foo>(doudarou);
var f2 = new[] {
new Foo {
A = 10, B = 9999, C = 9999999
},
new Foo {
A = 101, B = 43, C = 234
},
new Foo {
A = 20, B = 5666, C = 1111
},
};
var doudarou2 = MessagePackSerializer.Serialize(f2, UnsafeDirectBlitResolver.Instance);
var two2 = MessagePackSerializer.Deserialize <Foo[]>(doudarou2);
Console.WriteLine(string.Join(", ", doudarou2));
}
static void Main(string[] args)
{
CompositeResolver.RegisterAndSetAsDefault(new[]
{
EnumResolver.UnderlyingValue,
StandardResolver.ExcludeNullCamelCase
});
//bind eventhandlers
IEventHandler eventHandler = ServiceProvider.GetService <IEventHandler>();
IEventHandlerCallback eventHandlerCallback = ServiceProvider.GetService <IEventHandlerCallback>();
try
{
eventHandler.Start(eventHandlerCallback);
}
catch (Exception ex)
{
Console.WriteLine("Error occured during eventhandler startup check logs for info" + ex.Message);
Environment.Exit(1);
}
Console.WriteLine("Up and running and ready to rumble!");
while (true)
{
Thread.Sleep(10000);
}
}
public Form1()
{
//Set MessagePack Resolvers
CompositeResolver.RegisterAndSetAsDefault(
DynamicObjectResolverAllowPrivate.Instance,
StandardResolver.Instance
);
InitializeComponent();
complexAnimationData = new ComplexAnimation();
//labelFrameCount.DataBindings.Add(complexAnimationData.GetFrameCountDataBinding()); //Not working ...
complexAnimationData.OnFrameCountChanged(ComplexDataFramecountChanged);
IEnumerable <Animation.AnimationType> animationTypes = Enum.GetValues(typeof(Animation.AnimationType)).Cast <Animation.AnimationType>();
foreach (Animation.AnimationType aT in animationTypes)
{
comboBoxAnimationType.Items.Add(aT.ToString());
}
comboBoxAnimationType.SelectedItem = null;
comboBoxAnimationType.SelectedIndex = 1;
UpdateFrameDataOutput(-1);
}
internal void OutputJSON(object jObj, ListFlags toolFlags)
{
try {
CompositeResolver.RegisterAndSetAsDefault(new IJsonFormatter[] {
new ResourceGUIDFormatter()
}, new[] {
StandardResolver.Default
});
} catch {
// rip, already registered and set as default???
}
byte[] json = Utf8Json.JsonSerializer.NonGeneric.Serialize(jObj.GetType(), jObj);
if (!string.IsNullOrWhiteSpace(toolFlags.Output))
{
byte[] pretty = Utf8Json.JsonSerializer.PrettyPrintByteArray(json);
Log("Writing to {0}", toolFlags.Output);
CreateDirectoryFromFile(toolFlags.Output);
var fileName = !toolFlags.Output.EndsWith(".json") ? $"{toolFlags.Output}.json" : toolFlags.Output;
using (Stream file = File.OpenWrite(fileName)) {
file.SetLength(0);
file.Write(pretty, 0, pretty.Length);
}
}
else
{
Console.Error.WriteLine(Utf8Json.JsonSerializer.PrettyPrint(json));
}
}
internal DbConfiguration(ResolverChain appConfigChain, ResolverChain normalResolverChain, RootDependencyResolver rootResolver)
{
Contract.Requires(appConfigChain != null);
Contract.Requires(normalResolverChain != null);
_rootResolver = rootResolver;
_resolvers = new CompositeResolver<ResolverChain, ResolverChain>(appConfigChain, normalResolverChain);
_resolvers.Second.Add(_rootResolver);
}
public void GetService_can_be_accessed_from_multiple_threads_concurrently()
{
for (var i = 0; i < 30; i++)
{
var bag = new ConcurrentBag<IPilkington>();
var karl1 = new Mock<IPilkington>().Object;
var resolver = new CompositeResolver<IDbDependencyResolver, IDbDependencyResolver>(
new SingletonDependencyResolver<IPilkington>(karl1),
new SingletonDependencyResolver<IPilkington>(new Mock<IPilkington>().Object));
ExecuteInParallel(() => bag.Add(resolver.GetService<IPilkington>()));
Assert.Equal(20, bag.Count);
Assert.True(bag.All(c => karl1 == c));
}
}
internal Engine(Action<long> idleAction, Action<long> mainAction, Job targetJob, Action setupAction, Action cleanupAction, long operationsPerInvoke, bool isDiagnoserAttached)
{
IdleAction = idleAction;
MainAction = mainAction;
TargetJob = targetJob;
SetupAction = setupAction;
CleanupAction = cleanupAction;
OperationsPerInvoke = operationsPerInvoke;
IsDiagnoserAttached = isDiagnoserAttached;
Resolver = new CompositeResolver(BenchmarkRunnerCore.DefaultResolver, EngineResolver.Instance);
Clock = targetJob.ResolveValue(InfrastructureMode.ClockCharacteristic, Resolver);
ForceAllocations = targetJob.ResolveValue(GcMode.ForceCharacteristic, Resolver);
UnrollFactor = targetJob.ResolveValue(RunMode.UnrollFactorCharacteristic, Resolver);
Strategy = targetJob.ResolveValue(RunMode.RunStrategyCharacteristic, Resolver);
EvaluateOverhead = targetJob.ResolveValue(AccuracyMode.EvaluateOverheadCharacteristic, Resolver);
InvocationCount = targetJob.ResolveValue(RunMode.InvocationCountCharacteristic, Resolver);
warmupStage = new EngineWarmupStage(this);
pilotStage = new EnginePilotStage(this);
targetStage = new EngineTargetStage(this);
}
public void Given()
{
resolver = new CompositeResolver(new SimpleResolver {new MockSubscription<MessageA>()},
new SimpleResolver { new MockSubscription<MessageA>(), new MockSubscription<MessageB>()});
}
/// <summary>
/// This method is not thread-safe and should only be used to switch in a different root resolver
/// before the configuration is locked and set. It is used for pushing a new configuration by
/// DbContextInfo while maintaining legacy settings (such as database initializers) that are
/// set on the root resolver.
/// </summary>
internal virtual void SwitchInRootResolver(RootDependencyResolver value)
{
Contract.Requires(value != null);
Contract.Assert(!_isLocked);
// The following is not thread-safe but this code is only called when pushing a configuration
// and happens to a new DbConfiguration before it has been set and locked.
var newChain = new ResolverChain();
newChain.Add(value);
_resolvers.Second.Resolvers.Skip(1).Each(newChain.Add);
_rootResolver = value;
_resolvers = new CompositeResolver<ResolverChain, ResolverChain>(_resolvers.First, newChain);
}
public When_Resolving_Subscriptions()
{
_resolver = new CompositeResolver(new SimpleResolver {new MockSubscription<MessageA>()},
new SimpleResolver { new MockSubscription<MessageA>(), new MockSubscription<MessageB>()});
}
