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