public V Execute(T data)
{
if (!Disposed)
{
DividedResource dividedResource = DividedResourceManager.CreateDividedResource(data);
try
{
List <DistributedComputingResult> distributedResults = null;
try
{
distributedResults = Task.ExecuteTask(dividedResource);
}
catch
{
throw new NoServerConnectionException();
}
if (distributedResults == null)
{
throw new TaskException();
}
List <V> results = new List <V>();
var serializer = new DataContractSerializer(typeof(V));
foreach (DistributedComputingResult distributedResult in distributedResults)
{
bool read = false;
DistributedResource resource = distributedResult.Result;
while (!read)
{
try
{
byte[] array = resource.Get();
results.Add((V)serializer.ReadObject(new MemoryStream(array)));
distributedResult.Result.Dispose();
read = true;
}
catch (Exception e)
{
resource = Task.Execute(distributedResult.Data);
if (resource == null)
{
throw new NoServerConnectionException();
}
}
}
}
return(new Compiler().CompileResult(results));
}
finally
{
dividedResource.Dispose();
}
}
else
{
throw new ObjectDisposedException(this.ToString());
}
}
public List <DistributedComputingResult> ExecuteTask(DividedResource resource)
{
try
{
var service = RemoteConnection.CreateProxy <IServerTaskService>(Server);
return(service.ExecuteTask(Client, Id, resource));
}
catch
{
throw new NoServerConnectionException();
}
}
public List <DistributedComputingResult> ExecuteTask(Uri clientUri, int taskId, DividedResource resource)
{
Logging.WriteLog("Request for executing task was received");
if (Server.Workers.Count == 0)
{
return(null);
}
List <TaskExecutor> executors = DistributingStrategy.Distribute(clientUri, resource.Resources, Server.Workers);
var task = ExecuteTaskAsync(clientUri, taskId, executors, resource.Resources.Count);
task.Wait();
var result = task.Result;
return(result);
}
