public JStringBuilder(int capacity)
{
var objectPoolProvider = new DefaultObjectPoolProvider();
_stringBuilderPool = objectPoolProvider.CreateStringBuilderPool(capacity, capacity * 2);
_stringBuilder = _stringBuilderPool.Get();
}
public void GetDictionary()
{
var ObjectPool = new DefaultObjectPoolProvider().CreateStringBuilderPool();
var TestObject = new SpellChecker(new ISpellingDictionary[] { new CountrySpellChecker(ObjectPool) });
Assert.Equal("Country", TestObject.GetDictionary("Country").Name);
}
NotepadLoggerProvider()
{
var poolProvider = new DefaultObjectPoolProvider();
stringBuilderPool = poolProvider.CreateStringBuilderPool();
windowFinder = new WindowFinder();
}
private IReadOnlyList <ApiDescription> GetApiDescriptions()
{
var context = new ApiDescriptionProviderContext(_actionDescriptors);
var options = new MvcOptions();
var cfg = JsonSerializerSettingsProvider.CreateSerializerSettings();
var apool = ArrayPool <char> .Shared;
var opool = new DefaultObjectPoolProvider();
options.InputFormatters.Add(new JsonInputFormatter(new Mock <ILogger>().Object, cfg, apool, opool));
options.OutputFormatters.Add(new JsonOutputFormatter(cfg, apool));
var optionsAccessor = new Mock <IOptions <MvcOptions> >();
optionsAccessor.Setup(o => o.Value).Returns(options);
var constraintResolver = new Mock <IInlineConstraintResolver>();
constraintResolver.Setup(i => i.ResolveConstraint("int")).Returns(new IntRouteConstraint());
var provider = new DefaultApiDescriptionProvider(
optionsAccessor.Object,
constraintResolver.Object,
CreateDefaultProvider()
);
provider.OnProvidersExecuting(context);
provider.OnProvidersExecuted(context);
return(new ReadOnlyCollection <ApiDescription>(context.Results));
}
/// <inheritdoc/>
public IDuplicatePropertyNameChecker GetDuplicatePropertyNameChecker()
{
IDuplicatePropertyNameChecker duplicatePropertyNameChecker;
if (settings.ThrowOnDuplicatePropertyNames)
{
#if NETSTANDARD2_0_OR_GREATER
if (this.duplicatePropertyNameCheckerObjectPool == null)
{
DefaultObjectPoolProvider poolProvider = new DefaultObjectPoolProvider {
MaximumRetained = 8
};
this.duplicatePropertyNameCheckerObjectPool = poolProvider.Create <DuplicatePropertyNameChecker>();
}
duplicatePropertyNameChecker = this.duplicatePropertyNameCheckerObjectPool.Get();
duplicatePropertyNameChecker.Reset();
#else
duplicatePropertyNameChecker = new DuplicatePropertyNameChecker();
#endif
}
else
{
if (this.nullDuplicatePropertyNameChecker == null)
{
// NullDuplicatePropertyNameChecker does nothing, so we can use a single instance during the writing process.
this.nullDuplicatePropertyNameChecker = new NullDuplicatePropertyNameChecker();
}
duplicatePropertyNameChecker = this.nullDuplicatePropertyNameChecker;
}
return(duplicatePropertyNameChecker);
}
public MazeServerOptions()
{
var loggerFactory = NullLoggerFactory.Instance;
var charPool = ArrayPool <char> .Shared;
var objectPool = new DefaultObjectPoolProvider();
InputFormatters = new Collection <IInputFormatter>
{
new JsonInputFormatter(loggerFactory.CreateLogger <JsonInputFormatter>(), SerializerSettings, charPool,
objectPool),
new JsonPatchInputFormatter(loggerFactory.CreateLogger <JsonPatchInputFormatter>(), SerializerSettings,
charPool, objectPool)
};
OutputFormatters = new List <IOutputFormatter>
{
new JsonOutputFormatter(SerializerSettings, charPool)
};
ModelBinderProviders = new List <IModelBinderProvider>
{
new ServicesModelBinderProvider(),
new BodyModelBinderProvider(InputFormatters,
new MemoryPoolHttpRequestStreamReaderFactory(ArrayPool <byte> .Shared, charPool)),
new EnumTypeModelBinderProvider(),
new SimpleTypeModelBinderProvider(),
new ByteArrayModelBinderProvider(),
new CancellationTokenModelBinderProvider()
};
}
public JStringBuilder(int initCapacity, int maxCapacity)
{
var objectPoolProvider = new DefaultObjectPoolProvider();
_stringBuilderPool = objectPoolProvider.CreateStringBuilderPool(initCapacity, maxCapacity);
_stringBuilder = _stringBuilderPool.Get();
}
public void CheckSpelling(string input, string expected)
{
var ObjectPool = new DefaultObjectPoolProvider().CreateStringBuilderPool();
var TestObject = new SpellChecker(new ISpellingDictionary[] { new CountrySpellChecker(ObjectPool) });
Assert.Equal(expected, TestObject.GetDictionary("Country").Correct(input));
}
public JStringBuilder()
{
var objectPoolProvider = new DefaultObjectPoolProvider();
_stringBuilderPool = objectPoolProvider.CreateStringBuilderPool();
_stringBuilder = _stringBuilderPool.Get();
}
public static ConnegRules Empty()
{
var provider = new DefaultObjectPoolProvider();
var graph = new HttpSerializationGraph(new HttpSettings(new MessagingSettings()), provider, new Forwarders(), new ISerializerFactory[0], new IMessageDeserializer[0], new IMessageSerializer[0]);
return(new ConnegRules(graph, new IReaderRule[0], new IWriterRule[0]));
}
/// <summary>
/// Loads the module
/// </summary>
/// <param name="bootstrapper">Bootstrapper to register with</param>
public void Load(IBootstrapper?bootstrapper)
{
var objectPoolProvider = new DefaultObjectPoolProvider();
bootstrapper?.Register(typeof(GenericComparer <>), ServiceLifetime.Singleton)
.Register(typeof(GenericEqualityComparer <>), ServiceLifetime.Singleton)
.Register(new DynamoTypes(), ServiceLifetime.Singleton)
.Register(objectPoolProvider.CreateStringBuilderPool(), ServiceLifetime.Singleton);
}
/// <summary>
/// Initializes a new instance of the <see cref="PoolActivator{TLimit}"/> class.
/// </summary>
/// <param name="pooledInstanceService">The service used to resolve new instances of the pooled registration.</param>
/// <param name="policy">The pool policy.</param>
public PoolActivator(Service pooledInstanceService, IPooledRegistrationPolicy <TLimit> policy)
{
_pooledInstanceService = pooledInstanceService;
_policy = policy;
_poolProvider = new DefaultObjectPoolProvider
{
MaximumRetained = policy.MaximumRetained
};
}
private CustomRouteValuesBasedEndpointFinder CreateEndpointFinder(params EndpointDataSource[] endpointDataSources)
{
var objectPoolProvider = new DefaultObjectPoolProvider();
var objectPool = objectPoolProvider.Create(new UriBuilderContextPooledObjectPolicy());
return(new CustomRouteValuesBasedEndpointFinder(
new CompositeEndpointDataSource(endpointDataSources),
objectPool));
}
public RelaySender(IOptions <RelayOptions> relayOptions, FeatureSerializerManager featureSerializerManager) : base(relayOptions)
{
var clientsPoolProvider = new DefaultObjectPoolProvider
{
MaximumRetained = relayOptions.Value.ClientsPoolSize
};
var hybridConnectionClient = new HybridConnectionClient(relayOptions.Value.ConnectionString);
_clientsPool = clientsPoolProvider.Create(new RelayClientPooledObjectPolicy(hybridConnectionClient, featureSerializerManager));
}
public void Setup()
{
var objectPoolProvider = new DefaultObjectPoolProvider();
StringBuilderPool = objectPoolProvider.CreateStringBuilderPool();
for (var x = 0; x < char.MaxValue; ++x)
{
Value += (char)x + " ";
}
}
static StringBuilderPool()
{
var provider = new DefaultObjectPoolProvider();
var policy = new StringBuilderPooledObjectPolicy
{
MaximumRetainedCapacity = MaximumBuilderSize,
};
Pool = provider.Create(policy);
}
public void DefaultObjectPoolProvider_CreateForIDisposable_DisposableObjectPoolReturned()
{
// Arrange
var provider = new DefaultObjectPoolProvider();
// Act
var pool = provider.Create <DisposableObject>();
// Assert
Assert.IsType <DisposableObjectPool <DisposableObject> >(pool);
}
public void Ctor_ShouldThrowArgumentNullException_GivenNullOptions()
{
var options = default(JsonSerializerOptions);
var pool = new DefaultObjectPoolProvider().Create <TestClass>();
var ex = Assert.Throws <ArgumentNullException>(
() => new PoolingJsonConverter <TestClass>(options, pool)
);
Assert.Equal("options", ex.ParamName);
}
static async Task <int> Main(string[] args)
{
var arg = args.ElementAtOrDefault(0) ?? "";
if (!Enum.TryParse <Command>(arg, ignoreCase: true, out var command))
{
return(1);
}
var provider = new DefaultObjectPoolProvider();
var pool = provider.Create <Message <double> >();
var jsonOptions = new JsonSerializerOptions()
.AddPoolingConverter(pool);
var builder = new HubConnectionBuilder()
.WithUrl("http://localhost:5000/hubs/messaging")
.AddJsonProtocol(options =>
{
options.PayloadSerializerOptions = jsonOptions;
});
var connection = builder.Build();
await connection.StartAsync();
var cts = new CancellationTokenSource();
Console.CancelKeyPress += (sender, e) =>
{
if (cts.IsCancellationRequested)
{
return;
}
Console.WriteLine("Stopping...");
e.Cancel = true;
cts.Cancel();
};
ICommandHandler handler = command switch
{
Command.Receive => new Receiver(pool, connection),
Command.Send => new Sender(pool, connection),
_ => throw new InvalidOperationException("Invalid command"),
};
Console.WriteLine($"Starting {handler}...");
handler.Start(cts.Token);
cts.Token.WaitHandle.WaitOne();
return(0);
}
public IBusControl Create(Action <BusControlConfigurator> configure)
{
var busConfigurator = new BusControlConfigurator(
(options, rpcTimeout, messageTtl, queueTtl) =>
{
var provider = new DefaultObjectPoolProvider();
var channelPool = provider.Create(new RabbitModelPooledObjectPolicy(options));
return(new RabbitMqBusControl(channelPool, rpcTimeout, messageTtl, queueTtl));
});
configure.Invoke(busConfigurator);
return(busConfigurator.BusControl);
}
private static TreeRouteBuilder CreateBuilder()
{
var objectPoolProvider = new DefaultObjectPoolProvider();
var objectPolicy = new UriBuilderContextPooledObjectPolicy();
var objectPool = objectPoolProvider.Create(objectPolicy);
var constraintResolver = GetInlineConstraintResolver();
var builder = new TreeRouteBuilder(
NullLoggerFactory.Instance,
objectPool,
constraintResolver);
return builder;
}
public PoolingDeserializeTest(string simpleJson, string complexJson)
{
_simpleJson = simpleJson;
_complexJson = complexJson;
var provider = new DefaultObjectPoolProvider();
_simplePool = provider.Create(new DefaultPooledObjectPolicy <Simple>());
_complexPool = provider.Create(new DefaultPooledObjectPolicy <Complex>());
_options = new JsonSerializerOptions()
.AddPoolingConverter(_simplePool)
.AddPoolingConverter(_complexPool);
}
private static TreeRouteBuilder CreateBuilder()
{
var objectPoolProvider = new DefaultObjectPoolProvider();
var objectPolicy = new UriBuilderContextPooledObjectPolicy(UrlEncoder.Default);
var objectPool = objectPoolProvider.Create <UriBuildingContext>(objectPolicy);
var constraintResolver = Mock.Of <IInlineConstraintResolver>();
var builder = new TreeRouteBuilder(
NullLoggerFactory.Instance,
UrlEncoder.Default,
objectPool,
constraintResolver);
return(builder);
}
private static TreeRouteBuilder CreateBuilder()
{
var objectPoolProvider = new DefaultObjectPoolProvider();
var objectPolicy = new UriBuilderContextPooledObjectPolicy();
var objectPool = objectPoolProvider.Create(objectPolicy);
var constraintResolver = GetInlineConstraintResolver();
#pragma warning disable CS0618 // Type or member is obsolete
var builder = new TreeRouteBuilder(
NullLoggerFactory.Instance,
objectPool,
constraintResolver);
#pragma warning restore CS0618 // Type or member is obsolete
return(builder);
}
public void Deserialize_ShouldThrowJsonException_GivenMissingStartObject()
{
var pool = new DefaultObjectPoolProvider().Create <TestClass>();
var options = new JsonSerializerOptions().AddPoolingConverter(
pool
);
var json = JsonSerializer.Serialize(TestClass.Random(), options);
json = "[" + json.Substring(1);
var ex = Assert.Throws <JsonException>(() => JsonSerializer.Deserialize <TestClass>(json, options));
var expected = $"Type mismatch expected: {JsonTokenType.StartObject}, actual: {JsonTokenType.StartArray}";
var actual = ex.Message;
Assert.Equal(expected, actual);
}
private static void Main()
{
const string extensionsSuffix = "Extensions";
var stringBuilderPool = new DefaultObjectPoolProvider()
.CreateStringBuilderPool();
var extensionGroups = typeof(DependencyObjectExtensions).Assembly
.GetExportedTypes()
.Where(x => x.Name.EndsWith(extensionsSuffix))
.GroupBy(x =>
{
// ReSharper disable once PossibleNullReferenceException
var groupSeparatorIndex = x.Namespace.LastIndexOf('.');
return(x.Namespace.Substring(groupSeparatorIndex + 1));
}, x => (x.Name, Funcs: x.GetMethods(BindingFlags.Public | BindingFlags.Static)))
.OrderBy(x => x.Key)
.Select(grouping =>
{
var classes = grouping
.Select(x =>
{
var funcNames = x.Funcs
.Select(y => y.Name)
.Distinct()
.OrderBy(y => y);
return(stringBuilderPool.Get()
.AppendFormat(" - **{0}** - ", x.Name.Replace(extensionsSuffix, string.Empty))
.AppendJoin(", ", funcNames)
.ToString());
});
return(stringBuilderPool.Get()
.AppendFormat("### {0} extensions:", grouping.Key)
.AppendLine()
.AppendJoin(';' + Environment.NewLine, classes)
.ToString());
});
var description = stringBuilderPool.Get()
.AppendJoin('.' + Environment.NewLine + Environment.NewLine, extensionGroups)
.Append('.')
.ToString();
}
static JsonValidator()
{
var objectPoolProvider = new DefaultObjectPoolProvider();
StringBuilderPool = objectPoolProvider.CreateStringBuilderPool();
var accessor = new ResourceAccessor(Assembly.GetExecutingAssembly());
var libManager = new LibraryManager(
Assembly.GetExecutingAssembly(),
new LibraryItem(Platform.Windows, Bitness.x64,
new LibraryFile("nlohmann_json_schema_validator.dll",
accessor.Binary("nlohmann_json_schema_validator.dll"))),
new LibraryItem(Platform.Linux, Bitness.x64,
new LibraryFile("libnlohmann_json_schema_validator.so",
accessor.Binary("libnlohmann_json_schema_validator.so"))));
libManager.LoadNativeLibrary();
}
public void Run()
{
var provider = new DefaultObjectPoolProvider();
// Create your own pools
ObjectPool <Point> pool = provider.Create <Point>();
var options = new JsonSerializerOptions()
.AddPoolingConverter(pool);
string json = "{\"X\":10,\"Y\":53}";
var p = JsonSerializer.Deserialize <Point>(json, options);
DoWork(p);
pool.Return(p);
}
public void Setup()
{
var provider = new DefaultObjectPoolProvider();
_simplePool = provider.Create(new DefaultPooledObjectPolicy <Simple>());
_clonerPool = new JsonCloner(
new JsonSerializerOptions()
.AddPoolingConverter(_simplePool)
);
_clonerNoPool = new JsonCloner(
new JsonSerializerOptions()
);
_root = new Simple {
Int32 = int.MaxValue
};
}
public void ConfigureServices(IServiceCollection services)
{
var provider = new DefaultObjectPoolProvider();
var pool = provider.Create <Message <double> >();
var jsonOptions = new JsonSerializerOptions()
.AddPoolingConverter(pool);
services.AddSingleton <ObjectPoolProvider>(provider);
services.AddSingleton(pool);
services
.AddSignalR(options => {
})
.AddJsonProtocol(options => {
options.PayloadSerializerOptions = jsonOptions;
});
}
