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);
}
