public void Dispose()
{
if (this == null || wasDisposed || !ViewInitialized)
{
return;
}
wasDisposed = true;
OnDispose();
RemoveTickable(this);
_dManager.Remove(this);
//Debug.Log(this + " disposed");
if (disposeControllerOnDispose && Controller != null)
{
Controller.Dispose();
}
Controller = null;
_eventService = null;
_dManager = null;
_tManager = null;
}
public void Dispose()
{
if (this == null || wasDisposed || !ViewInitialized)
{
return;
}
wasDisposed = true;
OnDispose();
if (this.gameObject != null && destroyOnDispose)
{
disposeOnDestroy = false;
Destroy(this.gameObject);
}
//_tManager.Remove(this);
RemoveTickable(this);
_dManager.Remove(this);
Controller = null;
ControllerProperty.Dispose();
ViewInitializedProperty.Dispose();
Model = null;
ModelProperty.Dispose();
_eventService = null;
_dManager = null;
_tManager = null;
}
private void _Initialize(
[Inject] DiContainer container,
[Inject] IEventsService eventService,
[Inject] DisposableManager dManager
)
{
if (initialized == true)
{
return;
}
initialized = true;
PreBind();
Container = container;
_dManager = dManager;
_eventService = eventService;
_dManager.Add(this);
this.ModelProperty.DistinctUntilChanged().Subscribe(e => ListenToModelDispose()).AddTo(this);
if (createModelOnBind && Model == null)
{
IModel _m = CreateModel();
_m.Bind();
SetModel(_m);
}
AfterBind();
//UnityEngine.Debug.Log(this + " init");
}
void Initialize(
[Inject] DiContainer diContainer,
[Inject] DisposableManager dManager,
[Inject] TickableManager tManager,
[Inject] IEventsService eventService)
{
if (isInitialized)
{
return;
}
isInitialized = true;
Container = diContainer;
_dManager = dManager;
_tManager = tManager;
_eventService = eventService;
//To make IDisposable work, we have to add this instance to the disposable manager
_dManager.Add(this);
//Make ITickable and INetworkTickable work
AddTickable(this);
//Bind all interfaces for this instance
Container.Bind <ITickable>().FromInstance(this);
Container.Bind <IDisposable>().FromInstance(this);
//Container.BindAllInterfacesFromInstance(this);
AfterBind();
}
void Initialize(
[Inject] DisposableManager dManager,
[Inject] Service.Events.IEventsService eventService,
[Inject] Service.AsyncManager.IAsyncManager asyncManager
)
{
_dManager = dManager;
_eventService = eventService;
_asyncManager = asyncManager;
// register as disposable
_dManager.Add(this);
try {
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
AfterInitialize();
watch.Stop();
#if UNITY_EDITOR || DEVELOPMENT_BUILD
UnityEngine.Debug.LogWarning($"Service /*name:serviceName*/PrototypeService/*endname*/ AfterInitialize() took {watch.Elapsed.TotalSeconds}s");
#endif
Observable.NextFrame().Subscribe(_ => {
InitAPI();
});
}
catch (Exception e) {
UnityEngine.Debug.LogError("Catched exception in AfterInitialize() from service:" + GetType());
UnityEngine.Debug.LogException(e);
}
}
public void Dispose()
{
if (wasDisposed || Kernel.applicationQuitting)
{
return;
}
wasDisposed = true;
OnDispose();
//Tell subscribers that controller is disposing
OnDisposing.Execute();
OnDisposing.Dispose();
OnDisposing = null;
Disposables.Dispose();
controllerEventsSubject.Dispose();
controllerEventsSubject = null;
viewEventsSubject.Dispose();
viewEventsSubject = null;
Model = null;
Container = null;
_eventService = null;
_dManager = null;
ModelProperty.Dispose();
ModelProperty = null;
}
void Initialize(
[Inject] IEventsService eventService,
[Inject] DisposableManager dManager
)
{
if (isInitialized)
{
return;
}
_eventService = eventService;
_dManager = dManager;
_dManager.Add(this);
NetworkStateProperty = new ReactiveProperty <NetworkStateEnum>(NetworkStateEnum.Disconnected);
customConfig = true;
autoCreatePlayer = false;
scriptCRCCheck = false;
connectionConfig.AddChannel(QosType.ReliableSequenced);
connectionConfig.AddChannel(QosType.ReliableFragmented);
connectionConfig.AddChannel(QosType.UnreliableSequenced);
connectionConfig.AddChannel(QosType.Unreliable);
connectionConfig.DisconnectTimeout = 2000;
connectionConfig.PingTimeout = 1500;
connectionConfig.NetworkDropThreshold = 90;
isInitialized = true;
Tickrate = 15;
}
public void Dispose()
{
if (this == null || wasDisposed || !ViewInitialized)
{
return;
}
wasDisposed = true;
OnDispose();
if (this.gameObject != null && destroyOnDispose)
{
disposeOnDestroy = false;
Destroy(this.gameObject);
}
//_tManager.Remove(this);
RemoveTickable(this);
_dManager.Remove(this);
//Debug.Log(this + " disposed");
if (disposeControllerOnDispose && Controller != null)
{
Controller.Dispose();
}
Controller = null;
_eventService = null;
_dManager = null;
_tManager = null;
}
private IDisposable Subscribe(IStreamObserver <TKey, TSource> observer, int index)
{
IDisposable child;
lock (this.subscriptionLock)
{
if (this.toSubscribe.Add(index))
{
child = new ChildDisposable(this.connectableStream.Subscribe(observer), this.crew, index);
}
else
{
throw new InvalidOperationException("Cannot subscribe to the same child streamable more than once.");
}
if (this.toSubscribe.Count == this.outputCount)
{
this.crew.SetListDisposable(this.connectableStream.Connect());
this.crew = new DisposableManager(this.outputCount);
this.connectableStream = new ConnectableStreamable <TKey, TSource>(this.source);
this.toSubscribe.Clear();
}
}
return(child);
}
void Start()
{
//Resolve disposableManager
dManager = Container.Resolve <DisposableManager>();
//Let the program know, that Kernel has finished loading
eventService = Container.Resolve <Service.Events.IEventsService>();
eventService.Publish(new Events.KernelReadyEvent());
}
private NWayMulticast(IStreamable <TKey, TSource> source, int outputCount)
{
Contract.Requires(source != null);
Contract.Requires(outputCount > 0);
this.source = source;
this.connectableStream = new ConnectableStreamable <TKey, TSource>(source);
this.outputCount = outputCount;
this.crew = new DisposableManager(outputCount);
}
void Initialize(
[Inject] DisposableManager dManager,
[Inject] Service.Events.IEventsService eventService
)
{
_dManager = dManager;
_eventService = eventService;
_dManager.Add(this);
}
public void Init(
SignalBus signalBus,
DisposableManager disposableManager,
ISignalService signalService
)
{
SignalBus = signalBus;
SignalService = signalService;
_disposableManager = disposableManager;
}
void Initialize(
[Inject] Service.Events.IEventsService eventService,
[Inject] DisposableManager dManager
)
{
_eventService = eventService;
_dManager = dManager;
_dManager.Add(this);
disposables.Add(_eventService.OnEvent <Service.Backend.Events.GotUserDataEvent>().Subscribe(e => OnGotUserData(e)));
}
void Initialize(
[Inject] DisposableManager dManager,
[Inject] Service.Events.IEventsService eventService,
[Inject] Service.AsyncManager.IAsyncManager asyncManager
) {
_dManager = dManager;
_eventService = eventService;
_asyncManager = asyncManager;
// register as disposable
_dManager.Add(this);
AfterInitialize();
}
public void Dispose_Clears_Internal_Collection()
{
//Arrange
var disposable1 = Substitute.For <IDisposable>();
//Act
var dm = new DisposableManager();
dm.Register <IDisposable>(disposable1);
dm.Dispose();
dm.Dispose();
//Assert
disposable1.Received(1).Dispose();
}
public void Register_Multiple_Test()
{
//Arrange
var disposable1 = Substitute.For <IDisposable>();
var disposable2 = Substitute.For <IDisposable>();
//Act
var dm = new DisposableManager();
dm.Register(disposable1, disposable2);
dm.Dispose();
//Assert
disposable1.Received(1).Dispose();
disposable2.Received(1).Dispose();
}
public void Register_Single_Test()
{
//Arrange
var disposable1 = Substitute.For <IDisposable>();
//Act
var dm = new DisposableManager();
var disposable2 = dm.Register <IDisposable>(disposable1);
dm.Dispose();
//Assert
disposable1.Received(1).Dispose();
disposable2.Received(1).Dispose();
disposable1.Should().Be(disposable2);
}
public void Dispose_Ignores_Exceptions()
{
//Arrange
var disposable1 = Substitute.For <IDisposable>();
var disposable2 = Substitute.For <IDisposable>();
disposable1.When(x => x.Dispose()).Throw <Exception>();
//Act
var dm = new DisposableManager();
dm.Register(disposable1, disposable2);
dm.Dispose();
//Assert
disposable1.Received(1).Dispose();
disposable2.Received(1).Dispose();
}
void Initialize(
[Inject] DiContainer diContainer,
[Inject] DisposableManager dManager,
[Inject] TickableManager tManager,
[Inject] IEventsService eventService)
{
if (isInitialized)
{
return;
}
isInitialized = true;
PreBind();
Container = diContainer;
_dManager = dManager;
_tManager = tManager;
_eventService = eventService;
Profiler.BeginSample("dmanager add");
//To make IDisposable work, we have to add this instance to the disposable manager
_dManager.Add(this);
Profiler.EndSample();
//Make ITickable work
Profiler.BeginSample("Add tickable");
// this takes most of the time
AddTickable(this);
Profiler.EndSample();
//Bind all interfaces for this instance
Profiler.BeginSample("ITickable fromInstance");
Container.Bind <ITickable>().FromInstance(this);
Profiler.EndSample();
Profiler.BeginSample("IDisposable fromInstance");
Container.Bind <IDisposable>().FromInstance(this);
//Container.BindAllInterfacesFromInstance(this);
Profiler.EndSample();
Profiler.BeginSample("AfterBind");
AfterBind();
Profiler.EndSample();
}
public void Initialize(
[Inject] DiContainer diContainer,
[Inject] DisposableManager dManager,
[Inject] TickableManager tManager,
[Inject] Service.Events.IEventsService eventService)
{
if (ViewInitialized)
{
return;
}
ViewInitialized = true;
PreBind();
Container = diContainer;
_dManager = dManager;
_tManager = tManager;
_eventService = eventService;
this.ControllerProperty.DistinctUntilChanged().Subscribe(e => ListenToControllerDispose()).AddTo(this);
//Create controller if this view is created through editor/sceneload
if (createController && Controller == null)
{
IController _c = CreateController();
_c.Bind();
SetController(_c);
}
//To make IDisposable work, we have to add this instance to the disposable manager
_dManager.Add(this);
//Make ITickable work
AddTickable(this);
//Bind all interfaces for this instance
//Container.BindAllInterfacesFromInstance(this);
Container.Bind <IView>().FromInstance(this);
Container.Bind <ITickable>().FromInstance(this);
//Debug.Log(this + " init");
AfterBind();
}
void Initialize(
[Inject] DisposableManager dManager,
[Inject] Service.Events.IEventsService eventService,
[Inject] Service.AsyncManager.IAsyncManager asyncManager
)
{
_dManager = dManager;
_eventService = eventService;
_asyncManager = asyncManager;
// register as disposable
_dManager.Add(this);
try {
AfterInitialize();
}
catch (Exception e) {
UnityEngine.Debug.LogError("Catched exception in Service-AfterInitialize() from service:" + GetType());
UnityEngine.Debug.LogException(e);
}
}
void Initialize(
[Inject] DisposableManager dManager,
[Inject] Service.Events.IEventsService eventService
)
{
_dManager = dManager;
_eventService = eventService;
_dManager.Add(this);
//Fire events on button up/down
disposables.Add(Observable.EveryUpdate().Subscribe(e => {
if (inputEnabled)
{
//Check button down
foreach (KeyValuePair <object, List <Func <bool> > > kv in buttonDownHandlers)
{
if (GetButtonDown(kv.Key))
{
_eventService.Publish(new Events.ButtonDownEvent()
{
button = kv.Key
});
}
}
//Check button up
foreach (KeyValuePair <object, List <Func <bool> > > kv in buttonUpHandlers)
{
if (GetButtonUp(kv.Key))
{
_eventService.Publish(new Events.ButtonUpEvent()
{
button = kv.Key
});
}
}
}
}));
}
protected virtual void Start()
{
//Resolve disposableManager
dManager = Container.Resolve <DisposableManager>();
//Let the program know, that Kernel has finished loading
// first start rxStartup-queue
// if this is finished, start initial gamestate
rxStartup
.RxExecute()
.SelectMany(_ => {
string initialGameStateName = GetInitialGamestateName();
Service.GameStateService.GSContext initialGameStateCtx = GetInitialGamestateContext();
if (initialGameStateName == null)
{
Debug.LogWarning("No inital gamestate specified!");
return(Observable.Return(true));
}
else
{
Service.GameStateService.IGameStateService gameStateService = Container.Resolve <Service.GameStateService.IGameStateService>();
Service.GameStateService.GameState initialGameState = gameStateService.GetGameState(initialGameStateName);
if (initialGameState == null)
{
Debug.LogWarning("Could not find initial gamestate with name:" + initialGameStateName);
return(Observable.Return(true));
}
return(gameStateService.StartGameState(initialGameState, initialGameStateCtx).Do(__ => { Debug.Log("Started initial gamestate:" + initialGameStateName); }));
}
})
.Last()
.Take(1)
.Subscribe(_ => {
KernelReady = true;
Debug.LogWarning("Startup done!");
OnKernelReady();
});
}
void _Initialize(
[Inject] DiContainer _container,
[Inject] DisposableManager dManager,
[Inject] ISerializerService serializerService,
[Inject] IEventsService eventService)
{
if (initialized)
{
return;
}
initialized = true;
Bind();
Container = _container;
_dManager = dManager;
_eventService = eventService;
_serializerService = serializerService;
_dManager.Add(this);
AfterBind();
}
void _Initialize(
[Inject] DiContainer _container,
[Inject] DisposableManager dManager,
[Inject] ISerializerService serializerService,
[Inject] IEventsService eventService)
{
if (initialized)
{
return;
}
initialized = true;
Bind(delayAfterBind);
if (bindAllListener != null)
{
bindAllListener.Dispose();
}
bindAllListener = null;
Container = _container;
_dManager = dManager;
_eventService = eventService;
_serializerService = serializerService;
_dManager.Add(this);
OnAfterBind.Execute();
if (!delayAfterBind)
{
AfterBind();
}
else
{
Observable.NextFrame().Subscribe(e => AfterBind()).AddTo(this);
}
}
private void _Initialize(
[Inject] DiContainer container,
[Inject] IEventsService eventService,
[Inject] DisposableManager dManager
)
{
if (initialized == true)
{
return;
}
initialized = true;
PreBind();
Container = container;
_dManager = dManager;
_eventService = eventService;
_dManager.Add(this);
this.ModelProperty.DistinctUntilChanged().Subscribe(e => ListenToModelDispose()).AddTo(this);
AfterBind();
}
public void Execute()
{
//
// 通常パターン.
//
using (var disposable1 = new Disposable1())
{
using (var disposable2 = new Disposable2())
{
using (var disposable3 = new Disposable3())
{
Output.WriteLine("Dispose Start..");
}
}
}
//
// 通常パターン: DisposableManager利用.
//
using (var manager = new DisposableManager())
{
manager.Add(new Disposable1());
manager.Add(new Disposable2());
manager.Add(new Disposable3());
Output.WriteLine("Dispose Start..");
}
//
// 条件が存在し、作成されないオブジェクトが存在する可能性がある場合.
//
Disposable1 dispose1 = null;
Disposable2 dispose2 = null;
Disposable3 dispose3 = null;
var isDispose2Create = false;
try
{
dispose1 = new Disposable1();
if (isDispose2Create)
{
dispose2 = new Disposable2();
}
dispose3 = new Disposable3();
}
finally
{
Output.WriteLine("Dispose Start..");
DisposeIfNotNull(dispose1);
DisposeIfNotNull(dispose2);
DisposeIfNotNull(dispose3);
}
//
// 条件あり: DisposableManager利用.
//
dispose1 = null;
dispose2 = null;
dispose3 = null;
using (var manager = new DisposableManager())
{
dispose1 = manager.Add(new Disposable1());
if (isDispose2Create)
{
dispose2 = manager.Add(new Disposable2());
}
dispose3 = manager.Add(new Disposable3());
Output.WriteLine("Dispose Start..");
}
}
public ChildDisposable(IDisposable inner, DisposableManager crew, int index)
{
this.inner = inner;
this.crew = crew;
this.index = index;
}
