public void PropertyChanged_should_call_weakly_subscribed_handler_when_handler_is_collected() { // Arrange var observer = new Observer(); var model = new SomeModel(observer); Action<int> onChange = model.Change; var weakOnChange = new WeakReference(onChange); var counter = Reactive.Of(0); counter.PropertyChanged += (sender, args) => { var handler = weakOnChange.Target as Action<int>; if (handler != null) handler(counter); }; // Act onChange = null; GC.Collect(); counter.Value = 1; // Assert observer.ChangedObserved.Should().BeFalse(); }
public void AjouterObservateur(Observer observer) { if (!observers.Contains(observer)) { observers.Add(observer); } }
static void Demo() { Subject subject = new Subject(); Observer Observer = new Observer(subject, "Center", "\t\t"); Observer observer2 = new Observer(subject, "Right", "\t\t\t\t"); subject.Go(); }
public NSObject AddObserver(string name, Action<NSNotification> action, NSObject fromObject = null) { var handler = new Observer(action); Callbacks.Subscribe(handler, SelectorName, n => action(Runtime.GetNSObject<NSNotification>(n))); ObjC.MessageSend(Handle, Selector.GetHandle("addObserver:selector:name:object:"), handler.Handle, Selector.GetHandle(SelectorName), name, fromObject == null ? IntPtr.Zero : fromObject.Handle); return handler; }
public void Main() { var subject = new Subject(); var Observer = new Observer(subject, "Center", "\t\t"); var observer2 = new Observer(subject, "Right", "\t\t\t\t"); subject.Go(); }
public void RegisterObserver(Observer.IObserver o) { if (o != null) { observerCollection.Add(o); } }
public void UnregisterObserver(Observer.IObserver o) { if (o != null) { observerCollection.Remove(o); } }
/// <summary> /// Adds an observer to recieve our notifications. /// </summary> /// <param name='os'> /// An array of Observers to add. /// </param> public void AddObserver(Observer[] os) { foreach (Observer o in os) { AddObserver (o); } }
/// <summary> /// Removes the observer. /// </summary> /// <param name="observer">The observer.</param> public void RemoveObserver(Observer observer) { if (observers.Contains(observer)) { observers.Remove(observer); } }
public void SubscribeObserver(Observer observer) { if (!_subscribedObservers.Contains(observer)) { _subscribedObservers.Add(observer); } }
// inser at begining fo the queue public void Insert(Behaviour behaviour, Observer observer) { if(observer != null){ behaviour.observer = observer; } behaviours.Push(behaviour); }
public void RemoveObserver(Observer o) { if (observerList.Contains(o)) { observerList.Remove(o); } }
static void Main(){ IStack stacy = new StackImpl1(); StackDecorator1 orrico = new StackDecorator1(stacy); Observer StackObserver1 = new Observer(); Observer StackObserver2 = new Observer(); orrico.attach(StackObserver1); orrico.attach(StackObserver2); orrico.howMany(); orrico.pushStack("Stella"); orrico.pushStack("was"); orrico.pushStack("a"); orrico.pushStack("Diver"); // Sin decorar stacy.pushStack("and"); stacy.pushStack("she"); stacy.pushStack("was"); stacy.pushStack("always"); stacy.pushStack("down"); // decorar Sin orrico.howMany(); orrico.popStack(); orrico.howMany(); }
public FolderManager() { InitializeComponent(); _bobserver = new BObserver(); _observer = null; }
/// <summary> /// Adds the observer. /// </summary> /// <param name="observer">The observer.</param> public void AddObserver(Observer observer) { if (!observers.Contains(observer)) { observers.Add(observer); } }
/// <summary> /// Adds an observer to recieve our notifications. /// </summary> /// <param name='o'> /// An Observer to add. /// </param> public void AddObserver(Observer o) { if (!observerList.Contains (o)) { observerList.Add (o); } }
public void Init() { player1Observer = new MockObserver("Player1 Observer"); fullPlayerObserver = new MockObserver("FullPlayer Observer"); player1InventoryObserver = new MockObserver("Player 1 Inventory Observer"); fullPlayerInventoryObserver = new MockObserver("FullPlayer Inventory Observer"); player1 = new Player ("Player1", Gender.FEMALE, "Eve2", new Vector2 (0, 0)); player1.AddObserver(player1Observer); fullPlayer = new Player ("Ollie", Gender.MALE, "Evan1", Vector2.zero); fullPlayer.InitialiseInventory (20); fullPlayer.AddObserver(fullPlayerObserver); fullPlayer.Inventory.AddObserver(fullPlayerInventoryObserver); for (int i = 0; i < 20; i++) { InventoryItem item = new InventoryItem(); item.ItemName = "Item" + i; item.ItemId = i; item.ItemType = ItemType.RUBBISH; item.ItemDescription = string.Empty; fullPlayer.AddItem(item); } tool1 = new MockTool("Tool1"); tool2 = new MockTool("Tool2"); tool3 = new MockTool("Tool3"); fullPlayer.AddTool(tool1); fullPlayer.AddTool(tool2); fullPlayer.AddTool(tool3); }
public static ICommCore GetInstance(BasicConf conf, Observer<DataEventArgs> observer) { lock (SyncObject) { return _CommInstance ?? (_CommInstance = new CommService(conf, observer)); } }
public void addObserver(Observer o) { if (observers.Contains(o)) { return; } observers.Add(o); }
/// <summary> /// Construct with obesrver /// </summary> /// <param name="_observer"></param> public void Instantiate(Observer _observer) { // Save reference to observer this.observer = _observer; // Add self to observer this.observer.Add(this); }
public static void RemoveObserver( Observer oldObserver ) { if ( listOfObservers.Contains( oldObserver ) ) { listOfObservers.Remove( oldObserver ); } else { Debug.LogWarning( "List Doesn't Contain Observer" ); } }
public static void AddObserver( Observer newObserver ) { if ( !listOfObservers.Contains( newObserver ) ) { listOfObservers.Add( newObserver ); return; } Debug.LogWarning( "List Already Contains Observer" ); }
public Exercise2Game() { graphics = new GraphicsDeviceManager(this); Content.RootDirectory = "Content"; counter = new FrameCounter(); observer = counter; }
// para crear el Observador public void attach(Observer fisgon) { observadores.Add(fisgon); // observadores[Observer.] // observadores.Append(fisgon); // Array.AsReadOnly // que hace esto? }
public Form1() { InitializeComponent(); bicycle = new BicycleMointor(); observer = new Observer(lblRPM, bicycle); cph = new CPHObserver(lblCPH, bicycle); kph = new KPHObserver(lblKPH, bicycle); }
public static void RemoveObserver( Observer oldObserver ) { if( listOfObservers.Contains( oldObserver ) ) { listOfObservers.Remove( oldObserver ); } else { Debug.LogWarning( "No observer named " + oldObserver.ToString( ) ); } }
public static void AddObserver( Observer newObserver ) { if( !listOfObservers.Contains( newObserver ) ) { listOfObservers.Add( newObserver ); } else { Debug.LogWarning( "List already contains " + newObserver.ToString( ) ); } }
public void registerObserver(Observer o) { foreach (Observer observer in observers) { if (observer.Equals(o)) return; } observers.Add(o); }
public void AddObserver(Observer o, string ressourceName) { quantities.AddObserver(o, ressourceName); double x; if (!quantities.TryGetValue(ressourceName, out x)) { quantities.Add(ressourceName, 0); } }
public int Add(Observer observer) { try { _FileOContext.Observers.Add(observer); return _FileOContext.SaveChanges(); } catch (Exception) { return 0; } }
public abstract void Detach(Observer theObserver);
public void registerObserver(Observer observer) { throw new NotImplementedException(); }
internal Unsubscriber(List <Observer> observers, Observer observer) { this.m_observers = observers; this.m_observer = observer; }
public void removeObserver(Observer o) { observers.Remove(o); }
private void OnChannelMessage(string targetId, string @event, string data) { if (targetId != Internal.TransportId) { return; } switch (@event) { case "tuple": { var notification = JsonConvert.DeserializeObject <PlainTransportTupleNotificationData>(data); Tuple = notification.Tuple; Emit("tuple", Tuple); // Emit observer event. Observer.Emit("tuple", Tuple); break; } case "rtcptuple": { var notification = JsonConvert.DeserializeObject <PlainTransportRtcpTupleNotificationData>(data); RtcpTuple = notification.RtcpTuple; Emit("rtcptuple", RtcpTuple); // Emit observer event. Observer.Emit("rtcptuple", RtcpTuple); break; } case "sctpstatechange": { var notification = JsonConvert.DeserializeObject <TransportSctpStateChangeNotificationData>(data); SctpState = notification.SctpState; Emit("sctpstatechange", SctpState); // Emit observer event. Observer.Emit("sctpstatechange", SctpState); break; } case "trace": { var trace = JsonConvert.DeserializeObject <TransportTraceEventData>(data); Emit("trace", trace); // Emit observer event. Observer.Emit("trace", trace); break; } default: { _logger.LogError($"OnChannelMessage() | ignoring unknown event{@event}"); break; } } }
// public abstract void Attach(Observer listener);
public void Notify(Observer observer) { observer.Update(_currentState); }
public void dettach(Observer observer) { observers.Remove(observer); }
/* * Observable interface */ public void attach(Observer observer) { observers.Add(observer); }
public static IObserver <DisposableByteBuffer> ToFrameClientObserver(this Socket socket, SocketFlags socketFlags, Selector selector, CancellationToken token) { return(Observer.Create <DisposableByteBuffer>(disposableBuffer => { var header = BitConverter.GetBytes(disposableBuffer.Length); var headerState = new BufferState(header, 0, header.Length); var contentState = new BufferState(disposableBuffer.Bytes, 0, disposableBuffer.Length); try { headerState.Advance(socket.Send(headerState.Bytes, headerState.Offset, headerState.Length, socketFlags)); if (headerState.Length == 0) { contentState.Advance(socket.Send(contentState.Bytes, contentState.Offset, contentState.Length, socketFlags)); } if (contentState.Length == 0) { return; } } catch (Exception exception) { if (!exception.IsWouldBlock()) { throw; } } var waitEvent = new AutoResetEvent(false); var waitHandles = new[] { token.WaitHandle, waitEvent }; Exception error = null; selector.AddCallback(SelectMode.SelectWrite, socket, _ => { try { if (headerState.Length > 0) { headerState.Advance(socket.Send(headerState.Bytes, headerState.Offset, headerState.Length, socketFlags)); } if (headerState.Length == 0) { contentState.Advance(socket.Send(contentState.Bytes, contentState.Offset, contentState.Length, socketFlags)); } if (contentState.Length == 0) { selector.RemoveCallback(SelectMode.SelectWrite, socket); waitEvent.Set(); } } catch (Exception exception) { if (exception.IsWouldBlock()) { return; } error = exception; selector.RemoveCallback(SelectMode.SelectWrite, socket); waitEvent.Set(); } }); while (headerState.Length > 0 && contentState.Length > 0) { if (WaitHandle.WaitAny(waitHandles) == 0) { token.ThrowIfCancellationRequested(); } if (error != null) { throw error; } } disposableBuffer.Dispose(); })); }
public void attach(Observer o) { hs = (Highscore)o; }
public void registerObserver(Observer observer) { observers.Add(observer); }
public void registerObserver(Observer observer) { duck.registerObserver(observer); //important , se ajunge mai intai la decorator si dupa la obiectul efectiv }
public ReceiveEndpointReadyObserver(IReceiveEndpoint receiveEndpoint, CancellationToken cancellationToken) { _observer = new Observer(receiveEndpoint, cancellationToken); }
public void register(Observer o) { observer = o; }
public void addObserver(Observer o) { observers.Add(o); }
////////////////////////////////////////////////////////////////////////////////////////// #region Methods ////////////////////////////////////////////////////////////////////////////////////////// private void createObserver() { m_observer = new Observer <CollisionObserver>(this); }
public static void AddObserver(Observer observer) { Observers.Add(observer); }
public void RemoveObserver(Observer observer) { observers.Remove(observer); }
public void addObserver(Observer observer) { observers.Add(observer); }
public void Dettach(Observer observer) { _observerList.Remove(observer); }
public void Attach(Observer observer) { _observerList.Add(observer); Notify(observer); }
public void AddObserver(Observer newOb) { observers.Add(newOb); }
/// <summary> /// Cast a value container as a observer. /// </summary> /// <typeparam name="TValue">The type of the value container's value.</typeparam> /// <param name="source">The source.</param> /// <returns></returns> public static IObserver <TValue> AsObserver <TValue>(this ValueContainer <TValue> source) { return(Observer.Create <TValue>(v => source.SetValueAndTryNotify(v))); }
public static void RemoveObserver(Observer observer) { Observers.Remove(observer); }
public void Subscribe(Observer o) { observers.Add(o); }
public void RemoveObserver(Observer trashOb) { observers.Remove(trashOb); }
public void registerObserver(Observer observer) { observable.registerObserver(observer); }
/// <summary> /// Adds an observer to the registry /// </summary> /// <param name="o">The observer to add to the registry</param> public void AddListener(Observer o) { _registry.Add(o); }
public void Unsubscribe(Observer o) { observers.Remove(o); }