/// <summary> /// <para>Asserts that the code path encapsulated by <paramref name="dlg"/> throws an /// exception of <typeparamref name="T"/> which is a subclass of <see cref="ArgumentException"/>, with /// parameter name of <paramref name="paramName"/>.</para> /// </summary> /// <typeparam name="T"> /// <para>The type of items that the collection contains.</para> /// </typeparam> /// <param name="paramName">The name of the expected <see langword="null"/> parameter.</param> /// <param name="dlg">The code path to execute.</param> /// <returns>The caught exception.</returns> /// <exception cref="ArgumentNullException"> /// <para><paramref name="dlg"/> is <see langword="null"/>.</para> /// </exception> public static T ThrowsArgumentException <T>(string paramName, ParameterlessDelegate dlg) where T : ArgumentException { var exc = ThrowsException <T>(dlg); Assert.AreEqual(paramName, exc.ParamName, "Incorrect parameter name of " + typeof(T).Name); return(exc); }
/// <summary> /// <para>Asserts that the code path encapsulated by <paramref name="dlg"/> throws an excpetion of type /// <typeparamref name="T"/>, and returns caught exception for additional optional validation.</para> /// </summary> /// <typeparam name="T">The exception type.</typeparam> /// <param name="dlg">The code path to execute.</param> /// <returns>The caught exception.</returns> /// <exception cref="ArgumentNullException"> /// <para><paramref name="dlg"/> is <see langword="null"/>.</para> /// </exception> public static T ThrowsException <T>(ParameterlessDelegate dlg) where T : Exception { if (dlg == null) { throw new ArgumentNullException("dlg"); } try { dlg(); } catch (Exception exc) { T ret = exc as T; if (ret != null) { return(ret); } Assert.Fail("Unexpected exception thrown: " + exc.ToString()); } Assert.Fail("No exception thrown."); return(null); }
private void Start() { if (autoLogin) { InitComplete += Login; } FB.Init(OnInitComplete); }
public void Set(string id, Transform scrollParent, ParameterlessDelegate callback) { detailsSet = callback; this.id = id; parentt = scrollParent; GameSparkRequests getPlayerDetail = new GameSparkRequests(); getPlayerDetail.Request("GetPlayerDataWithID", "ID", id, Callback); transform.SetParent(scrollParent); transform.localRotation = Quaternion.identity; transform.localScale = Vector3.one; transform.localPosition = new Vector3(transform.localPosition.x, transform.localPosition.y, 0); CheckOnline(); }
internal void Callback(Object sender, EventArgs e) { if (_argless) { ParameterlessDelegate del = FastDelegateCreator <ParameterlessDelegate> .BindTo(_target, _functionPointer); del(); } else { ParameterfulDelegate del = FastDelegateCreator <ParameterfulDelegate> .BindTo(_target, _functionPointer); del(sender, e); } }
/// <summary> /// <para>Executes a collection of methods in all possible combinations.</para> /// </summary> /// <param name="initializer"> /// <para>The method to execute before the execution of each method combination.</para> /// </param> /// <param name="finalizer"> /// <para>The method to execute after the execution of each method combination.</para> /// </param> /// <param name="arrangedMethods"> /// <para>The collection of methods to execute in all possible combinations.</para> /// </param> /// <exception cref="ArgumentNullException"> /// <para>The argument <paramref name="initializer"/> is <see langword="null"/>.</para> /// <para>-or-</para> /// <para>The argument <paramref name="finalizer"/> is <see langword="null"/>.</para> /// <para>-or-</para> /// <para>The argument <paramref name="arrangedMethods"/> is <see langword="null"/>.</para> /// </exception> public static void ExerciseAllCombinations( ParameterlessDelegate initializer, ParameterlessDelegate finalizer, params ParameterlessDelegate[] arrangedMethods) { if (initializer == null) { throw new ArgumentNullException("initializer"); } if (finalizer == null) { throw new ArgumentNullException("finalizer"); } if (arrangedMethods == null) { throw new ArgumentNullException("arrangedMethods"); } if (arrangedMethods.Length == 1) { initializer(); arrangedMethods[0](); finalizer(); } else if (arrangedMethods.Length > 1) { var workingSet = new List <ParameterlessDelegate>(arrangedMethods); for (int i = 0; i < workingSet.Count; i++) { var movingMethod = workingSet[0]; for (int j = 0; j < workingSet.Count - 1; j++) { initializer(); foreach (ParameterlessDelegate method in workingSet) { method(); } finalizer(); workingSet.RemoveAt(j); workingSet.Insert(j + 1, movingMethod); } } } }
/// <summary> /// <para>Asserts that the code path encapsulated by <paramref name="dlg"/> throws an /// <see cref="ArgumentOutOfRangeException"/> with parameter name of <paramref name="paramName"/>.</para> /// </summary> /// <param name="paramName">The name of the expected <see langword="null"/> parameter.</param> /// <param name="dlg">The delegate to execute.</param> /// <returns>The caught exception. Never <see langword="null"/>.</returns> /// <exception cref="ArgumentNullException"> /// <para><paramref name="paramName"/> is <see langword="null"/>.</para> /// <para>-or-</para> /// <para><paramref name="dlg"/> is <see langword="null"/>.</para> /// </exception> public static ArgumentOutOfRangeException ThrowsArgumentOutOfRangeException(string paramName, ParameterlessDelegate dlg) { var exc = ThrowsArgumentException <ArgumentOutOfRangeException>(paramName, dlg); return(exc); }
public AsyncSocketTask(SocketChannel socketChannel) { _socketChannel = socketChannel; _callback = () => Execute(false); }
private IEnumerator <bool> GetReceiveEnumerator(ParameterlessDelegate callback) { _receiveArgs.UserToken = callback; while (true) { if (_socket.ReceiveAsync(_receiveArgs)) { yield return(false); } if (!ValidateCompletedEvent(_receiveArgs, SocketAsyncOperation.Receive)) { yield break; } if (_receiveArgs.BytesTransferred == 0) { SetError(SocketError.ConnectionReset); yield break; } if (_operationType != OperationType.RoundTrip) { SetError(new InvalidOperationException("Received data when no round trip operation was pending.")); yield break; } int position = _receiveArgs.Offset; int count = _receiveArgs.BytesTransferred; if (!_responseHeader.IsComplete) { position += _responseHeader.Read(_receiveArgs.Buffer, position, count - position); if (!_responseHeader.IsComplete || count == position) { continue; } } if (_responseData == null) { _responseData = AsyncSocketClient.MemoryPool.Borrow(); } int countAvailable = count - position; int countNeeded = _responseHeader.MessageDataLength - (int)_responseData.Item.Length; if (countNeeded <= countAvailable) { _responseData.Item.Write(_receiveArgs.Buffer, position, countNeeded); _responseData.Item.Seek(0, SeekOrigin.Begin); if (_responseHeader.MessageLength == ServerMessage.EmptyReplyMessageLength && ServerMessage.IsEmptyMessage(_responseData.Item.GetBuffer(), (int)_responseData.Item.Position, (int)_responseHeader.MessageLength)) { _responseData.Dispose(); _responseData = null; } _responseReceived = true; } else { _responseData.Item.Write(_receiveArgs.Buffer, position, countAvailable); } if (IsOperationComplete) { yield return(true); } } }
private IEnumerator <bool> GetSendEnumerator( int timeout, IPoolItem <MemoryStream> sendData, OperationType type, Delegate resultAction, ParameterlessDelegate callback) { ValidateSocketForUse(); _sendData = sendData; _operationType = type; if (_operationType == OperationType.OneWay) { _oneWayResultAction = (Action <OneWayAsyncEventArgs>)resultAction; } else if (_operationType == OperationType.RoundTrip) { _roundTripResultAction = (Action <RoundTripAsyncEventArgs>)resultAction; _responseData = AsyncSocketClient.MemoryPool.Borrow(); } else { string message = string.Format("Unexpected operation type '{0}'", type); Debug.Fail(message); SetError(new InvalidOperationException(message)); yield break; } _socketArgs.UserToken = callback; if (_state == State.Uninitialized) { _state = State.Connecting; var connectTimeoutHandle = TaskMonitor.RegisterMonitor(_connectTimeout, _timeoutHandler, null); if (_socket.ConnectAsync(_socketArgs)) { yield return(false); } if (!connectTimeoutHandle.TrySetComplete()) { SetError(SocketError.TimedOut); yield break; } if (!ValidateCompletedEvent(_socketArgs, SocketAsyncOperation.Connect)) { yield break; } _state = State.Connected; ThreadPool.UnsafeQueueUserWorkItem(o => { var target = (SocketChannel)o; var task = new AsyncSocketTask(this); task.SetEnumerator(target.GetReceiveEnumerator(task.Callback)); task.Execute(false); }, this); } Debug.Assert(_sendData != null, "_sendData was not set prior to starting the send enumerator."); _socketArgs.SetBuffer(_sendData.Item.GetBuffer(), (int)_sendData.Item.Position, (int)_sendData.Item.Length); _timeoutHandle = TaskMonitor.RegisterMonitor(timeout, _timeoutHandler, null); if (_socket.SendAsync(_socketArgs)) { yield return(false); } if (!ValidateCompletedEvent(_socketArgs, SocketAsyncOperation.Send)) { yield break; } _messageSent = true; }
public void AddListener(ParameterlessDelegate listener) { listeners.Add(listener); }
/// <summary> /// <para>Asserts that the code path encapsulated by <paramref name="dlg"/> throws an /// <see cref="ApplicationException"/>.</para> /// </summary> /// <param name="dlg">The delegate to execute.</param> /// <returns>The caught exception. Never <see langword="null"/>.</returns> /// <exception cref="ArgumentNullException"> /// <para><paramref name="dlg"/> is <see langword="null"/>.</para> /// </exception> public static ApplicationException ThrowsApplicationException(ParameterlessDelegate dlg) { var exc = ThrowsException <ApplicationException>(dlg); return(exc); }
public void RemoveListener(ParameterlessDelegate listener) { listeners.Remove(listener); }
private IEnumerator<bool> GetReceiveEnumerator(ParameterlessDelegate callback) { _receiveArgs.UserToken = callback; while (true) { if (_socket.ReceiveAsync(_receiveArgs)) yield return false; if (!ValidateCompletedEvent(_receiveArgs, SocketAsyncOperation.Receive)) yield break; if (_receiveArgs.BytesTransferred == 0) { SetError(SocketError.ConnectionReset); yield break; } if (_operationType != OperationType.RoundTrip) { SetError(new InvalidOperationException("Received data when no round trip operation was pending.")); yield break; } int position = _receiveArgs.Offset; int count = _receiveArgs.BytesTransferred; if (!_responseHeader.IsComplete) { position += _responseHeader.Read(_receiveArgs.Buffer, position, count - position); if (!_responseHeader.IsComplete || count == position) continue; } if (_responseData == null) _responseData = AsyncSocketClient.MemoryPool.Borrow(); int countAvailable = count - position; int countNeeded = _responseHeader.MessageDataLength - (int)_responseData.Item.Length; if (countNeeded <= countAvailable) { _responseData.Item.Write(_receiveArgs.Buffer, position, countNeeded); _responseData.Item.Seek(0, SeekOrigin.Begin); if (_responseHeader.MessageLength == ServerMessage.EmptyReplyMessageLength && ServerMessage.IsEmptyMessage(_responseData.Item.GetBuffer(), (int)_responseData.Item.Position, (int)_responseHeader.MessageLength)) { _responseData.Dispose(); _responseData = null; } _responseReceived = true; } else { _responseData.Item.Write(_receiveArgs.Buffer, position, countAvailable); } if (IsOperationComplete) yield return true; } }
private IEnumerator<bool> GetSendEnumerator( int timeout, IPoolItem<MemoryStream> sendData, OperationType type, Delegate resultAction, ParameterlessDelegate callback) { ValidateSocketForUse(); _sendData = sendData; _operationType = type; if (_operationType == OperationType.OneWay) { _oneWayResultAction = (Action<OneWayAsyncEventArgs>)resultAction; } else if (_operationType == OperationType.RoundTrip) { _roundTripResultAction = (Action<RoundTripAsyncEventArgs>)resultAction; _responseData = AsyncSocketClient.MemoryPool.Borrow(); } else { string message = string.Format("Unexpected operation type '{0}'", type); Debug.Fail(message); SetError(new InvalidOperationException(message)); yield break; } _socketArgs.UserToken = callback; if (_state == State.Uninitialized) { _state = State.Connecting; var connectTimeoutHandle = TaskMonitor.RegisterMonitor(_connectTimeout, _timeoutHandler, null); if (_socket.ConnectAsync(_socketArgs)) yield return false; if (!connectTimeoutHandle.TrySetComplete()) { SetError(SocketError.TimedOut); yield break; } if (!ValidateCompletedEvent(_socketArgs, SocketAsyncOperation.Connect)) yield break; _state = State.Connected; ThreadPool.UnsafeQueueUserWorkItem(o => { var target = (SocketChannel)o; var task = new AsyncSocketTask(this); task.SetEnumerator(target.GetReceiveEnumerator(task.Callback)); task.Execute(false); }, this); } Debug.Assert(_sendData != null, "_sendData was not set prior to starting the send enumerator."); _socketArgs.SetBuffer(_sendData.Item.GetBuffer(), (int)_sendData.Item.Position, (int)_sendData.Item.Length); _timeoutHandle = TaskMonitor.RegisterMonitor(timeout, _timeoutHandler, null); if (_socket.SendAsync(_socketArgs)) yield return false; if (!ValidateCompletedEvent(_socketArgs, SocketAsyncOperation.Send)) yield break; _messageSent = true; }
private IEnumerator <bool> GetReceiveEnumerator(ParameterlessDelegate callback) { _receiveArgs.UserToken = callback; try { while (true) { if (_error != null) { yield break; } // note - it seems this is necessary because of a bug in the SendAsync function // see - http://social.msdn.microsoft.com/Forums/en-IE/ncl/thread/40fe397c-b1da-428e-a355-ee5a6b0b4d2c Thread.MemoryBarrier(); LogDebugStep("Receiving..."); yield return(!_socket.ReceiveAsync(_receiveArgs)); LogDebugStep("Receive Complete."); if (!ValidateCompletedEvent(_receiveArgs, SocketAsyncOperation.Receive)) { yield break; } if (_receiveArgs.BytesTransferred == 0) { SetError(SocketError.ConnectionReset); yield break; } if (_operationType != OperationType.RoundTrip) { SetError(new InvalidOperationException("Received data when no round trip operation was pending.")); yield break; } int position = _receiveArgs.Offset; int count = _receiveArgs.BytesTransferred; if (!_responseHeader.IsComplete) { position += _responseHeader.Read(_receiveArgs.Buffer, position, count - position); if (!_responseHeader.IsComplete || count == position) { if (_log.IsDebugEnabled) { LogDebugStep(string.Format("Received partial header {0:###,##0} bytes", count - position)); } continue; } } if (_responseData == null) { _responseData = AsyncSocketClient.MemoryPool.Borrow(); } int countAvailable = count - position; int countNeeded = _responseHeader.MessageDataLength - (int)_responseData.Item.Length; if (countNeeded <= countAvailable) { _responseData.Item.Write(_receiveArgs.Buffer, position, countNeeded); _responseData.Item.Seek(0, SeekOrigin.Begin); if (_responseHeader.MessageLength == ServerMessage.EmptyReplyMessageLength && ServerMessage.IsEmptyMessage(_responseData.Item.GetBuffer(), (int)_responseData.Item.Position, _responseHeader.MessageLength)) { _responseData.Dispose(); _responseData = null; } _responseReceived = true; } else { _responseData.Item.Write(_receiveArgs.Buffer, position, countAvailable); } if (_log.IsDebugEnabled) { LogDebugStep(countAvailable + " of " + countNeeded + " bytes received. " + (countNeeded - countAvailable) + " bytes remaining. Complete=" + IsOperationComplete); } } } finally { LogDebugStep("Receive Loop Ended."); } }
private IEnumerator <bool> GetSendEnumerator( int timeout, IPoolItem <MemoryStream> sendData, OperationType type, Delegate resultAction, ParameterlessDelegate callback) { ValidateSocketForUse(); _sendData = sendData; _operationType = type; if (_operationType == OperationType.OneWay) { _oneWayResultAction = (Action <OneWayAsyncEventArgs>)resultAction; } else if (_operationType == OperationType.RoundTrip) { _roundTripResultAction = (Action <RoundTripAsyncEventArgs>)resultAction; _responseData = AsyncSocketClient.MemoryPool.Borrow(); } else { string message = string.Format("Unexpected operation type '{0}'", type); Debug.Fail(message); SetError(new InvalidOperationException(message)); yield break; } _socketArgs.UserToken = callback; if (_state == State.Uninitialized) { LogDebugStep("Connecting..."); _state = State.Connecting; var connectTimeoutHandle = TaskMonitor.RegisterMonitor(_connectTimeout, _timeoutHandler, null); if (_socket.ConnectAsync(_socketArgs)) { yield return(false); } if (!connectTimeoutHandle.TrySetComplete()) { LogDebugStep("Failed to set connection timeout handle complete."); SetError(SocketError.TimedOut); yield break; } if (!ValidateCompletedEvent(_socketArgs, SocketAsyncOperation.Connect)) { yield break; } _state = State.Connected; LogDebugStep("Connected."); ThreadPool.UnsafeQueueUserWorkItem(o => { var target = (SocketChannel)o; var task = new AsyncSocketTask(this); task.SetEnumerator(target.GetReceiveEnumerator(task.Callback)); task.Execute(false); }, this); } Debug.Assert(_sendData != null, "_sendData was not set prior to starting the send enumerator."); _socketArgs.SetBuffer(_sendData.Item.GetBuffer(), (int)_sendData.Item.Position, (int)_sendData.Item.Length); _timeoutHandle = TaskMonitor.RegisterMonitor(timeout, _timeoutHandler, null); // note - it seems this is necessary because of a bug in the SendAsync function // see - http://social.msdn.microsoft.com/Forums/en-IE/ncl/thread/40fe397c-b1da-428e-a355-ee5a6b0b4d2c Thread.MemoryBarrier(); if (_log.IsDebugEnabled) { LogDebugStep(string.Format("Sending {0:###,###,###,##0} bytes", _sendData.Item.Length - _sendData.Item.Position)); } if (_socket.SendAsync(_socketArgs)) { yield return(false); } if (!ValidateCompletedEvent(_socketArgs, SocketAsyncOperation.Send)) { yield break; } _messageSent = true; }