public async Task Parallelism(int maxParallelism)
{
const int count = 100000;
var idSeed = 0;
var swA = Stopwatch.StartNew();
using (var pool = new ObjectPool <TestObject>(100, () => new TestObject(Interlocked.Increment(ref idSeed))))
{
var tasks = Enumerable
.Range(0, maxParallelism)
.Select(t => Task.Run(() =>
{
for (var i = 0; i < count; i++)
{
// ReSharper disable AccessToDisposedClosure
var value = pool.Acquire();
value.WasteTime();
pool.Release(value);
// ReSharper restore AccessToDisposedClosure
}
}))
.ToArray();
await Task.WhenAll(tasks).ConfigureAwait(false);
}
swA.Stop();
_outputHelper.WriteLine($"MaxParallelism: {maxParallelism} - ElapsedMilliseconds: {swA.ElapsedMilliseconds}");
}
public static PreformattedStringImpl Create(string message)
{
var msg = _Pool.Acquire();
msg.message = message;
return(msg);
}
void Spawn(int index)
{
if (index < 0 || index >= spawnObjects.Length)
{
return;
}
var obj = spawnObjects[index];
var freq = obj.spawnFreq.Evaluate(passedTime);
if (Random.value > freq * Time.deltaTime)
{
return;
}
var scenebound = SceneValues.GetSceneBound();
var randomX = Random.Range(scenebound.min.x, scenebound.max.x);
var point = new Vector2(randomX, scenebound.max.y + spawnHeight);
if (spawnArea != null)
{
point = spawnArea.GetRandomPoint();
point.y = scenebound.max.y + spawnHeight;
}
var spawn = ObjectPool.Acquire(obj.obj);
spawn.transform.position = point;
}
private void Update()
{
if (!grid.GridIsFull())
{
if (CheckCooldownAvailability())
{
GameObject result;
string enemiesType = dataBase.GetTypes()[Random.Range(0, dataBase.GetTypes().Length)];
if (enemiesPool.Acquire(enemiesType, out result))
{
result.GetComponent <EnemiesBase>().Activate();
grid.AddObjectToGrid(result);
enemies.Add(result);
enemiesTypes.Add(enemiesType);
}
}
}
for (int i = 0; i < enemies.Count; i++)
{
if (enemies[i].GetComponent <EnemiesBase>().wasDestroyed)
{
grid.RemoveObjectFromGrid(enemies[i]);
enemiesPool.Release(enemiesTypes[i], enemies[i]);
enemies.Remove(enemies[i]);
enemiesTypes.Remove(enemiesTypes[i]);
}
}
}
private GameObject AcquireAndRegister(ObjectPool pool, Transform parent, ICollection <GameObject> activeObjCollection)
{
var lGameObj = pool.Acquire(parent);
activeObjCollection.Add(lGameObj);
return(lGameObj);
}
public void TestWithUpperBound()
{
using (var pool = new ObjectPool <StringBuilder>(2, () => new StringBuilder(), sb => sb.Length = 0))
{
Assert.That(pool.Count, Is.Zero);
Recurse(pool, 99);
Assert.That(pool.Count, Is.EqualTo(pool.MaxCapacity));
pool.Clear();
Assert.That(pool.Count, Is.EqualTo(0));
}
void Recurse(ObjectPool <StringBuilder> pool, int count)
{
if (count <= 0)
{
return;
}
using (var proxy = pool.Acquire())
{
proxy.Value.Append($"Test {count}");
Recurse(pool, count - 1);
Assert.That(proxy.ToString(), Is.EqualTo($"Test {count}"));
}
Assert.That(pool.Count, Is.LessThanOrEqualTo(pool.MaxCapacity));
}
}
public static LogMessageImpl Create(string message)
{
var msg = _Pool.Acquire();
msg.message = message;
return(msg);
}
public static SecureLogFieldImpl Create(string name, object value)
{
var field = _Pool.Acquire();
field.name = name;
field.value = value;
return(field);
}
public static ValueChangedEventArgs <T> Get(T oldValue, T newValue)
{
ValueChangedEventArgs <T> args = Pool.Acquire();
args.OldValue = oldValue;
args.NewValue = newValue;
return(args);
}
public override void AssignCollections()
{
base.AssignCollections();
if (_Transactions == null)
{
ObjectPool.Acquire(out _Transactions);
}
}
public virtual void AssignCollections()
{
if (Entries.Capacity < 0x40)
{
Entries.Capacity = 0x40;
}
if (_Linked == null)
{
ObjectPool.Acquire(out _Linked);
}
if (_Children == null)
{
ObjectPool.Acquire(out _Children);
}
if (_Controls == null)
{
ObjectPool.Acquire(out _Controls);
}
if (_Layout == null)
{
ObjectPool.Acquire(out _Layout);
}
if (_Buttons == null)
{
ObjectPool.Acquire(out _Buttons);
}
if (_TileButtons == null)
{
ObjectPool.Acquire(out _TileButtons);
}
if (_Switches == null)
{
ObjectPool.Acquire(out _Switches);
}
if (_Radios == null)
{
ObjectPool.Acquire(out _Radios);
}
if (_TextInputs == null)
{
ObjectPool.Acquire(out _TextInputs);
}
if (_LimitedTextInputs == null)
{
ObjectPool.Acquire(out _LimitedTextInputs);
}
}
/// <summary>
/// 拿取
/// </summary>
/// <param name="name"></param>
/// <param name="delayDespawnTime"></param>
/// <returns></returns>
public ball Spawn(float delayDespawnTime = 5)
{
ball b = _pool.Acquire();
if (delayDespawnTime != -1)
{
b.DelayDeSpawn(delayDespawnTime);
}
return(b);
}
public static LogFieldImpl Create(string name, object value, string format, string suffix)
{
var field = _Pool.Acquire();
field.name = name;
field.value = value;
field.format = format;
field.suffix = suffix;
return(field);
}
public void When_Acquire()
{
ObjectPool <StringBuilder> SUT = new ObjectPool <StringBuilder>(() => new StringBuilder(), null, ObjectPoolStoreMode.Queue, ObjectPoolLoadingMode.Eager);
using (var stringBuilder = SUT.Acquire(i => i.Clear()))
{
((StringBuilder)stringBuilder).Append("hello");
}
Assert.Inconclusive();
}
private void SpawnNewEnemy()
{
GameObject result;
string enemiesType = dataBase.GetTypes()[Random.Range(0, dataBase.GetTypes().Length)];
if (enemiesPool.Acquire(enemiesType, out result))
{
result.GetComponent <EnemyBase>().Activate();
spawnController.AddObjectToSpawner(result);
enemies.Add(result);
enemiesTypes.Add(enemiesType);
}
}
public void TestDefaultConstructor()
{
using (var pool = new ObjectPool <StringBuilder>(sb => sb.Length = 0))
{
Assert.That(pool.Count, Is.Zero);
using (var proxy = pool.Acquire())
{
proxy.Value.Append("Test");
Assert.That(proxy.ToString(), Is.EqualTo("Test"));
}
Assert.That(pool.Count, Is.EqualTo(1));
}
}
public string ProjectMessage(int index)
{
var info = GetEventInfo(index);
var formatter = messageFormatterPool.Acquire();
try {
return(formatter.GetMessageForEvent(
info, tdhContext, CultureInfo.CurrentCulture));
} finally {
messageFormatterPool.Release(formatter);
}
}
public void Fire(Vector2 position, float angle)
{
if (World.Laser.IsActive || _bulletDelay < _bulletRapidity)
{
return;
}
var bullet = _bulletsPool.Acquire();
bullet.Position = position;
bullet.Angle = angle;
_bulletDelay = 0;
}
public void TestImplicitCacting()
{
using (var pool = new ObjectPool <StringBuilder>(() => new StringBuilder(), sb => sb.Length = 0))
{
Assert.That(pool.Count, Is.Zero);
using (var proxy = pool.Acquire())
{
AppendSomething(proxy);
Assert.That(proxy.ToString(), Is.EqualTo("Something"));
}
Assert.That(pool.Count, Is.EqualTo(1));
}
void AppendSomething(StringBuilder sb) => sb.Append("Something");
}
protected override void SpawnOver()
{
base.SpawnOver();
if (firingEffect != null)
{
var obj = ObjectPool.Acquire(firingEffect);
obj.transform.position = firingPoint.position;
obj.transform.rotation = firingPoint.rotation;
}
if (fireSound != null)
{
fireSound.Play(0);
}
}
protected virtual void ConsumeTask()
{
while (true)
{
try
{
Action task = TaskQueue.Take();
IEntry <WorkerThread> entry = ObjectPool.Acquire();
entry.Object.SetTask(task);
}
catch
{
break;
}
}
}
public void TryAcquire()
{
var idSeed = 0;
using (var pool = new ObjectPool <TestObject>(1, () => new TestObject(Interlocked.Increment(ref idSeed))))
{
TestObject value;
Assert.False(pool.TryAcquire(out value));
value = pool.Acquire();
Assert.True(pool.Release(value));
Assert.False(pool.Release(value));
Assert.True(pool.TryAcquire(out value));
}
}
/// <summary>
/// 承受伤害
/// </summary>
/// <param name="damage"></param>
public void TakeDamage(float damage)
{
health.CurrentValue -= damage;
if (healthBar != null)
{
healthBar.value = health.CurrentValue / health.BaseValue;
}
if (health.CurrentValue <= 0)
{
ObjectPool.Acquire(BaoZha).transform.position = transform.position;
CameraEffect.Shake();
ReleaseSelf();
}
}
/// <summary>
/// 生成一个对象
/// </summary>
protected virtual void SpawnObject()
{
// 生成一个对象
SpawnableObject obj = ObjectPool.Acquire(objPrefab);
obj.transform.position = transform.position;
obj.transform.rotation = transform.rotation;
// 初始化对象
InitializeObject(obj);
obj.Initialize();
// 挂上对象毁灭事件
obj.Destroyed += CharacterDestroyed;
// 生成结束
SpawnOver();
}
protected virtual void OnTriggerEnter2D(Collider2D collider2D)
{
GameObject obj = ObjectPool.Acquire(hittingEffect);
obj.transform.position = transform.position;
obj.transform.rotation = transform.rotation;
// 寻找击中对象上的Character
Character character = collider2D.GetComponent <Character>();
if (character != null)
{
// 对这个Character造成伤害
character.TakeDamage(damage);
}
// 回收该子弹
ReleaseSelf();
}
/************************************************************************************************************************/
/// <summary>Draws the rest of the Inspector fields after the Animator field.</summary>
protected void DoOtherFieldsGUI()
{
var property = _AnimatorEditor.AnimatorProperty.Copy();
while (property.NextVisible(false))
{
var label = ObjectPool.Acquire <GUIContent>();
label.text = AnimancerGUI.GetNarrowText(property.displayName);
label.tooltip = property.tooltip;
// Let the target try to override.
if (DoOverridePropertyGUI(property.propertyPath, property, label))
{
continue;
}
// Otherwise draw the property normally.
EditorGUILayout.PropertyField(property, label, true);
ObjectPool.Release(label);
}
}
public virtual void Submit(Action task)
{
if (task == null)
{
throw new ArgumentNullException("task is null");
}
if (HasQueue)
{
if (TrySubmit(task))
{
return;
}
TaskQueue.Add(task);
return;
}
IEntry <WorkerThread> entry = ObjectPool.Acquire();
entry.Object.SetTask(task);
}
private void Update()
{
if (Input.GetKeyDown(ShootKey))
{
if (CheckCooldownAvailability())
{
GameObject result;
if (projectilesPool.Acquire(projectileType, out result))
{
result.GetComponent <Projectile>().Shoot(transform.position, Vector3.up, speedMultiplier);
projectiles.Add(result);
}
}
}
for (int i = 0; i < projectiles.Count; i++)
{
if (projectiles[i].GetComponent <Projectile>().hit)
{
projectilesPool.Release(projectileType, projectiles[i]);
projectiles.Remove(projectiles[i]);
}
}
}
private void SpawnAsteroid(AsteroidSize size = AsteroidSize.None, Vector2 position = new Vector2())
{
var asteroid = _asteroidsPool.Acquire();
if (size == AsteroidSize.None)
{
asteroid.RandomizeSize();
}
else
{
asteroid.Size = size;
}
if (position == Vector2.Zero)
{
asteroid.RandomizePosition();
}
else
{
asteroid.Position = position;
}
asteroid.RandomizeAngleAndSpeed();
}
public void AcquireAndRelease()
{
TestObject a, b, c, d, e, f;
var idSeed = 0;
using (var pool = new ObjectPool <TestObject>(2, () => new TestObject(Interlocked.Increment(ref idSeed))))
{
a = pool.Acquire();
b = pool.Acquire();
c = pool.Acquire();
pool.Release(c);
pool.Release(b);
pool.Release(a);
d = pool.Acquire();
e = pool.Acquire();
f = pool.Acquire();
pool.Release(f);
pool.Release(e);
pool.Release(d);
Assert.Equal(1, a.Id);
Assert.Equal(2, b.Id);
Assert.Equal(3, c.Id);
Assert.Same(b, d);
Assert.Same(c, e);
Assert.Equal(4, f.Id);
}
Assert.False(a.IsDisposed);
Assert.False(b.IsDisposed);
Assert.True(c.IsDisposed);
Assert.False(d.IsDisposed);
Assert.True(e.IsDisposed);
Assert.True(f.IsDisposed);
}
