public interface ISpaceTask<T>
{
  /// <summary>
  /// Computes a result, or throws an exception if unable to do so.
  /// </summary>
  /// <param name="spaceProxy">A proxy to the space in which this task is being executed.</param>
  /// <param name="tx">The transaction (if any) under which to work.</param>
  /// <returns>Computed result.</returns>
  T Execute(ISpaceProxy spaceProxy, ITransaction tx);
}

[Serializable]
public class CountTask : ISpaceTask<int> 
{
  private String _message;

  public CountTask(String message)
  {
    _message = message;
  }

  public int Execute(ISpaceProxy spaceProxy, ITransaction tx)
  {
    System.Console.WriteLine(message);
    return spaceProxy.Count();
  }
}

ISpaceProxy spaceProxy = // obtain a proxy to a space
//Execute the task on a specific node using a specified routing value (2)
//And inserting the calculation result to count variable
int count = spaceProxy.Execute(new CountTask("hello world"), 2);

public interface ISpaceTaskResultsReducer<R, T>
{
  /// <summary>
  /// Reduce a list of <see cref="SpaceTaskResult{T}"/> into a single result.
  /// </summary>
  /// <param name="results">The list of space task results to reduce.</param>
  /// <returns>Reduced result.</returns>
  R Reduce(SpaceTaskResultsCollection<T> results);
}

[Serializable]
public class DistributedCountTask : IDistributedSpaceTask<long, int> 
{
  private String _message;

  public CountTask(String message)
  {
    _message = message;
  }

  public int Execute(ISpaceProxy spaceProxy, ITransaction tx)
  {
    System.Console.WriteLine(message);
    return spaceProxy.Count(new Object());
  }
  
  public long Reduce(SpaceTaskResultsCollection<int> results)
  {
    int sum = 0;
    foreach(SpaceTaskResult<int> result in results)
    {
      if (result.Exception != null)
        throw result.Exception;
      sum += result.Result;
    }
    return result;
  }
}

ISpaceProxy spaceProxy = // obtain a proxy to a space
//Execute the task on all the primary nodes with in the cluster
//and inserting the calculation result to count variable
long count = spaceProxy.Execute(new DistributedCountTask("hello world"));

public interface ISpaceTaskResultsFilter<T>
{
  /// <summary>
  /// A callback invoked for each result that arrives as a result of a distributed space task execution allowing
  /// to access the result that caused this event, the events received so far, and the total expected results.     
  /// </summary>
  /// <param name="info">Current filter info.</param>
  /// <returns>Filter's decision</returns>
  SpaceTaskFilterDecision GetFilterDecision(SpaceTaskFilterInfo<T> info);
}

/// <summary>
/// Controls what should be done with the results of an <see cref="IDistributedSpaceTask{R,T}"/> execution.
/// </summary>
public enum SpaceTaskFilterDecision
{
  /// <summary>
  /// Continue processing the distributed task.
  /// </summary>
  Continue = 0,
  /// <summary>
  /// Break out of the processing of the distributed task and move
  /// to the reduce phase including the current result.
  /// </summary>
  Break = 1,
  /// <summary>
  /// Skip this result and continue processing the rest of the results.
  /// </summary>
  Skip = 2,
  /// <summary>
  /// Skip this result and breaks out of the processing of the distributed task
  /// and move to the reduce phase.
  /// </summary>
  SkipAndBreak = 3,
}

ISpaceProxy spaceProxy = // obtain a proxy to a space

ITransaction tx = spaceProxy.LocalTransactionManager.Create();
try
{
  //Execute the task on a specific node using a specified routing value (2)
  //And inserting the calculation result to count variable
  int count = spaceProxy.Execute(new ClearMyObjectTask(), 2, tx);
  tx.Commit();
}
catch(Exception ex)
{
  tx.Abort();
}

[Serializable]
public class ClearMyObjectTask : ISpaceTask<int> 
{
  public int Execute(ISpaceProxy spaceProxy, ITransaction tx)
  {
    MyObject template = new MyObject();
    int result spaceProxy.Count(template, tx);
    spaceProxy.Clear(template, tx);
    return result;
  }
}

ISpaceProxy spaceProxy = // obtain a proxy to a space
//Execute the task on all the primary nodes with in the cluster
IAsyncResult<long> asyncResult = spaceProxy.BeginExecute(new DistributedCountTask("hello world"), null /*callback*/, null /*state object*/);

...
//This will block until the result execution has arrived
long count = spaceProxy.EndExecute(asyncResult);

ISpaceProxy spaceProxy = // obtain a proxy to a space
//Execute the task on all the primary nodes with in the cluster
IAsyncResult<long> asyncResult = spaceProxy.BeginExecute(new DistributedCountTask("hello world"), null /*callback*/, null /*state object*/);

...
//This will block until the result execution has arrived
asyncResult.AsyncWaitHandle.WaitOne();
//Gets the actual result of the async execution
long count = spaceProxy.EndExecute(asyncResult);

ISpaceProxy spaceProxy = // obtain a proxy to a space
//Execute the task on all the primary nodes with in the cluster
spaceProxy.BeginExecute(new DistributedCountTask("hello world"),ResultCallBack, new MyStateObject());

...


public void ResultCallBack<long>(IAsyncResult<long> asyncResult)
{
	//Gets the state object attached to this execution
	MyStateObject stateObject = (MyStateObject)asyncResult.AsyncState;
	...
	//Gets the actual result of the async execution
	long count = spaceProxy.EndExecute(asyncResult);	
	...
}