void BattleWork(object threadParams)
{
ThreadParams param = threadParams as ThreadParams;
try
{
foreach (Battleground battleground in terrainManager.battlegrounds)
{
for (int i = param.startIndex; i <= param.endIndex; i++)
{
foreach (Creature creatureB in population)
{
if (population[i] != creatureB)
{
BattleStats stats = BattleSimulation.Battle(population[i], creatureB, battleground);
stats.winner.fitnessValue++;
battles++;
requiresUIUpdate = true;
}
}
}
}
}
finally
{
param.currentHandle.Set();
}
}
public void ProcessSocketConnection(object threadState)
{
ThreadParams state = (ThreadParams)threadState;
Console.WriteLine($"<SocketProcess>Thread {state.ThreadIndex} is processing connection"); //{state.ClientSocket.RemoteEndPoint}
// This should be an extra method. In general this code should be more modular!
byte[] recievBuffer = new byte[StorageSize];
if (state.ClientSocket.Poll(DataTimeReadout, SelectMode.SelectRead))
{
state.ClientSocket.Receive(recievBuffer);
}
else
{
Console.WriteLine("<SocketProcess>Got no data, aborting");
Cleanup();
}
// Do your data Processing in this Method.
DoWork(recievBuffer, state.ClientSocket);
Cleanup();
// This is a local Function introduced in c#7
void Cleanup()
{
Console.WriteLine("<SocketProcess>Doing clean up tasks");
state.ClientSocket.Shutdown(SocketShutdown.Both);
state.ClientSocket.Close();
state.ClientSocket.Dispose();
recievBuffer = new byte[StorageSize];
state.ThreadHandle.Set();
}
}
void CalculatePopulationFitnessThreaded()
{
ResetFitnessValue();
battles = 0;
if (populationSize / threadCount < threadCount)
{
threadCount = 2;
}
int threadSplit = populationSize / threadCount;
ManualResetEvent[] handles = new ManualResetEvent[threadCount];
for (int i = 0, j = 0; i < populationSize; i += threadSplit, j++)
{
handles[j] = new ManualResetEvent(false);
ThreadParams threadParams = new ThreadParams(i * threadSplit, Mathf.Min(populationSize - 1, i * threadSplit + threadSplit - 1));
threadParams.currentHandle = handles[j];
ThreadPool.QueueUserWorkItem(BattleWork, threadParams);
}
WaitHandle.WaitAll(handles);
//Sort highest fitness value to lowest
population.Sort((creatureA, creatureB) => creatureB.fitnessValue.CompareTo(creatureA.fitnessValue));
totalFitness = battles;
}
static void Main()
{
var taskList = new Task[NUMBER_THREADs];
Console.WriteLine("Main on thread = {0}", Thread.CurrentThread.ManagedThreadId);
System.Diagnostics.Debug.WriteLine("Main on thread = {0}", Thread.CurrentThread.ManagedThreadId);
ManualResetEvent[] doneThreads = new ManualResetEvent[NUMBER_THREADs];
ManualResetEvent syncStartThreads = new ManualResetEvent(false);
for (int i = 0; i < NUMBER_THREADs; i++)
{
doneThreads[i] = new ManualResetEvent(false);
ThreadParams threadParams = new ThreadParams() { startEvent = syncStartThreads, finishedEvent = doneThreads[i] };
var thr = new Thread(new ParameterizedThreadStart(ThreadRun));
thr.Start(threadParams);
}
syncStartThreads.Set();
WaitHandle.WaitAll(doneThreads);
Console.WriteLine("Finished processing {0} threads", NUMBER_THREADs);
System.Diagnostics.Debug.WriteLine("Finished processing {0} threads", NUMBER_THREADs);
Console.ReadLine();
}
private static void readFileThreadPool(object tParams)
{
//read the custom thread parameter object
ThreadParams tParamsInner = tParams as ThreadParams;
string sourceFileName = @tParamsInner.sourceFileName;
StringBuilder contents = new StringBuilder();
string nextLine;
int lineCounter = 1;
var sw = Stopwatch.StartNew(); // time the operation
using (var stream = new FileStream(sourceFileName, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultBufferSize, DefaultOptions))
{
using (var reader = new StreamReader(sourceFileName))
{
while ((nextLine = reader.ReadLine()) != null)
{
contents.AppendFormat("{0}. ", lineCounter);
contents.Append(nextLine);
contents.AppendLine();
lineCounter++;
textMethod.Append(nextLine);
textMethod.AppendLine();
}
}
}
textTime.Text = Convert.ToString(sw.Elapsed);
textMethod.AppendLine("Ending Tread Pool I/O...");
}
public void InitializeSocketProcessing()
{
waitHandles = new WaitHandle[MaxThreads];
for (int i = 0; i < MaxThreads; ++i)
{
waitHandles[i] = new AutoResetEvent(true);
}
listener = new Socket(SocketType.Stream, ProtocolType.Tcp);
listener.Bind(new IPEndPoint(IPAddress, Port));
listener.Listen(25);
while (true)
{
Console.WriteLine($"{prefix}Waiting for a TCP connection");
Socket sock = listener.Accept();
Console.WriteLine($"{prefix}Got a connection");
Console.WriteLine($"{prefix}Waiting for idle thread");
int index = WaitHandle.WaitAny(waitHandles);
Console.WriteLine($"{prefix}Starting new thread to process client");
ThreadParams context = new ThreadParams()
{
ThreadHandle = (AutoResetEvent)waitHandles[index],
ClientSocket = sock,
ThreadIndex = index
};
ThreadPool.QueueUserWorkItem(ProcessSocketConnection, context);
}
}
static void Thread(object arg)
{
ThreadParams threadParams = (ThreadParams)arg;
while (!stop_)
{
try
{
// Request the server
if (threadParams.level2)
{
// Request for the level2 history
var result = threadParams.client.QueryQuoteHistoryTicks(threadParams.timestamp, threadParams.count, threadParams.symbol, true);
}
if (threadParams.ticks)
{
// Request for the ticks history
var result = threadParams.client.QueryQuoteHistoryTicks(threadParams.timestamp, threadParams.count, threadParams.symbol, false);
}
if (threadParams.bars)
{
// Request for the bars history
var result = threadParams.client.QueryQuoteHistoryBars(threadParams.timestamp, threadParams.count, threadParams.symbol, threadParams.periodicity, threadParams.priceType);
}
}
catch (Exception exception)
{
Console.WriteLine("Error : " + exception.Message);
}
}
}
/// <summary>
/// Write record for squad i in XML file
/// </summary>
/// <param name="id">Squad ID. Defferent with IndexId which starts with zero</param>
/// <param name="record">String to write into XML element</param>
public static void WriteRecordBySquadId(int id, String record)
{
ParameterizedThreadStart p = new ParameterizedThreadStart(WriteRecordBySquadId);
Thread writeThread = new Thread(p);
ThreadParams threadParams = new ThreadParams(id, record, syncObject);
writeThread.Start(threadParams);
}
private void ParameterizedThread(object obj)
{
System.Threading.Thread.Sleep(500);
Int32 rowIndex = 0;
ThreadParams threadParams = (ThreadParams)obj;
FormProgress.delCloseForm deCloseForm = threadParams.FormProgress.CloseForm;
FormProgress.delSetBodyText deSetBodyText = threadParams.FormProgress.SetBodyText;
FormProgress.delSetProgressMaximum deSetProgressMaximum = threadParams.FormProgress.SetProgressMaximum;
FormProgress.delSetProgressPosition deSetProgressPosition = threadParams.FormProgress.SetProgressPosition;
//threadParams.FormProgress.Invoke(deSetBodyText, "Waiting on network...");
SqlDataSourceEnumerator instance = SqlDataSourceEnumerator.Instance;
System.Data.DataTable table = instance.GetDataSources();
threadParams.FormProgress.Invoke(deSetBodyText, "Populating " + table.Rows.Count + " servers...");
threadParams.FormProgress.Invoke(deSetProgressMaximum, table.Rows.Count);
foreach (System.Data.DataRow row in table.Rows)
{
SQLServerListObject sqlObject = new SQLServerListObject(row["ServerName"].ToString(),
row["InstanceName"].ToString(), row["Version"].ToString(), CBool(row["isClustered"]));
threadParams.OwnerForm.Invoke(threadParams.AddSQLServerToComboBox, sqlObject);
threadParams.FormProgress.Invoke(deSetProgressPosition, rowIndex++);
System.Threading.Thread.Sleep(10);
}
threadParams.FormProgress.Invoke(deCloseForm);
}
private void cboServername_DropDown(object sender, EventArgs e)
{
if (cboServerName.Items.Count == 0)
{
FormProgress FormProgress = new FormProgress();
System.Threading.Thread thread = new System.Threading.Thread(ParameterizedThread);
ThreadParams threadParams = new ThreadParams();
threadParams.OwnerForm = this;
threadParams.FormProgress = FormProgress;
threadParams.AddSQLServerToComboBox = AddSQLServerToComboBox;
thread.Start(threadParams);
FormProgress.EnableCancel(true);
if (FormProgress.ShowDialog() != DialogResult.OK)
{
if (thread.ThreadState != System.Threading.ThreadState.Stopped)
{
thread.Abort();
}
}
}
}
public async Task <IActionResult> GetMessageThread(int userId, [FromQuery] ThreadParams threadParams)
{
var sender = await _repo.GetUser(userId);
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
if (sender.Id == threadParams.SecondUserId)
{
return(BadRequest("User cannot text to himself"));
}
var messagesFromRepo = await _repo.GetMessageThread(userId, threadParams);
if (messagesFromRepo == null)
{
return(NoContent());
}
var messagesToSend = _mapper.Map <MessageReturnDto[]>(messagesFromRepo);
Response.AddPagination(messagesFromRepo.CurrentPage,
messagesFromRepo.PageSize,
messagesFromRepo.TotalCount,
messagesFromRepo.TotalPages);
return(Ok(messagesToSend));
}
public ChunkGenerator()
{
Thread generator = new Thread(p =>
{
ThreadParams parameters = ((ThreadParams)p);
BlockingCollection <Chunk> chunkList = parameters.chunkList;
OpenGL gl = new OpenGL();
gl.MakeCurrent();
Glfw.MakeContextCurrent(parameters.window);
while (parameters.running)
{
chunkList.Take().initialize(gl);
}
})
{
IsBackground = true
};
_parameters = new ThreadParams(_chunkList, Glfw.CreateWindow(1, 1, "", Monitor.None, ToolBox.window));
generator.Start(_parameters);
}
/// <summary>
/// Forces the import of the tvguide. Usable when testing the grabber
/// </summary>
/// <param name="folder">The folder where tvguide.xml or tvguide.lst is stored</param>
/// <param name="importXML">True to import tvguide.xml</param>
/// <param name="importLST">True to import files in tvguide.lst</param>
public void ForceImport(String folder, bool importXML, bool importLST)
{
string fileName = folder + @"\tvguide.xml";
if (System.IO.File.Exists(fileName) && importXML)
{
importXML = true;
}
fileName = folder + @"\tvguide.lst";
if (importLST && System.IO.File.Exists(fileName))
{
DateTime fileTime = DateTime.Parse(System.IO.File.GetLastWriteTime(fileName).ToString());
// for rounding errors!!!
importLST = true;
}
if (importXML || importLST)
{
ThreadParams tp = new ThreadParams();
tp._importDate = DateTime.MinValue;
tp._importLST = importLST;
tp._importXML = importXML;
this.ThreadFunctionImportTVGuide(tp);
}
}
/// <summary>
/// Adaptive version
/// </summary>
/// <param name="o"></param>
public void Fill_Voxels(object o)
{
ThreadParams T = (ThreadParams)o;
for (int x = T.startvoxel; x < T.endvoxel; x++)
{
for (int y = 0; y < VoxelCtY; y++)
{
for (int z = 0; z < VoxelCtZ; z++)
{
Voxel_Inv[x, y, z, T.m] = new List <int>();
Point VoxelMin = new Point(x * VoxelDims.x - Epsilon, y * VoxelDims.y - Epsilon, z * VoxelDims.z - Epsilon);
Point VoxelMax = new Point((x + 1) * VoxelDims.x + Epsilon, (y + 1) * VoxelDims.y + Epsilon, (z + 1) * VoxelDims.z + Epsilon);
AABB Box = new AABB(VoxelMin + OBox.Min, VoxelMax + OBox.Min);
Voxels[x, y, z] = Box;
for (int i = 0; i < Model[T.m].Polygon_Count; i++)
{
//Check for intersection between voxel x,y,z with Polygon i...
if (Box.PolyBoxOverlap(Model[T.m].Polygon_Vertices(i)))
{
Voxel_Inv[x, y, z, T.m].Add(i);
}
}
//Check for Null Voxels
if (Voxel_Inv[x, y, z, T.m] == null)
{
System.Windows.Forms.MessageBox.Show("Whoops... Null Voxels Detected");
}
///////////////////////
}
}
}
}
public void Start <T>(StoreAction <T> store,
ActionWithData <T> action,
StopCondition <T> closeConnectionCondition) where T : class
{
onStart();
try
{
serverSocket.Bind(ipEndPoint);
serverSocket.Listen(config.MaxConnections);
ThreadParams <T> param = new ThreadParams <T>(store, action, closeConnectionCondition);
Thread connectionListener = new Thread(Listen <T>);
connectionListener.Start(param);
string cmd;
while (true)
{
cmd = Console.ReadLine();
if (cmd.Equals(config.ServerStopCommand))
{
break;
}
}
connectionListener.Abort("Stopping server.");
connectionListener.Join();
serverSocket.Shutdown(SocketShutdown.Both);
serverSocket.Close();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
// Get batches to process
private void SplitBatchThread(object infoObj)
{
ThreadParams p = (ThreadParams)infoObj;
int min = p.min;
int max = p.max;
int batchSize = p.batchSize;
char[] start = new char[min];
char[] end = new char[max];
for (int i = 0; i < start.Length; i++)
{
start[i] = validChars.First();
}
for (int i = 0; i < end.Length; i++)
{
end[i] = validChars.Last();
}
List <Tuple <char[], char[]> > b = BreakPass.Split(batchSize, start, end, validChars);
foreach (Tuple <char[], char[]> t in b)
{
batchesNotProcessed.Add(t);
}
isReady = true;
BatchUpdate();
}
private void ExecCmd(object p)
{
ThreadParams tp = (ThreadParams)p;
string readCursor = null;
bool hasOutParams = false;
foreach (OracleParameter param in tp.cmd.Parameters)
{
if (param.OracleDbType == OracleDbType.RefCursor)
{
readCursor = param.ParameterName;
break;
}
else
{
if (param.Direction == ParameterDirection.Output || param.Direction == ParameterDirection.InputOutput)
{
hasOutParams = true;
break;
}
}
}
try
{
if (!String.IsNullOrEmpty(readCursor))
{
OracleDataAdapter da = new OracleDataAdapter(tp.cmd);
DataTable dt = new DataTable();
da.Fill(dt);
tp.ResultValue = dt;
}
else
{
if (hasOutParams)
{
tp.cmd.ExecuteNonQuery();
Dictionary <string, object> dict = new Dictionary <string, object>();
foreach (OracleParameter param in tp.cmd.Parameters)
{
if (param.Direction == ParameterDirection.Output || param.Direction == ParameterDirection.InputOutput)
{
dict.Add(param.ParameterName, param.Value);
}
}
tp.ResultValue = dict;
}
else
{
tp.ResultValue = tp.cmd.ExecuteScalar();
}
}
}
catch (Exception e)
{
tp.e = e;
}
}
public UserControl1(TabControl _tabcontrol1, Playlist _playlist)
{
InitializeComponent();
_sunccontext = SynchronizationContext.Current;
tabcontrol1 = _tabcontrol1;
tp = new ThreadParams() { player = this, command = PlayingCommand.Stop, playlist = _playlist, isTerminate = false, doStep = 0 };
th.IsBackground = true;
th.Start(tp);
}
private void Cleanup(ThreadParams state)
{
Console.WriteLine($"{prefix}Doing clean up tasks. Thread {state.ThreadIndex}");
state.ClientSocket.Shutdown(SocketShutdown.Both);
state.ClientSocket.Close();
state.ClientSocket.Dispose();
ReceivedBuffer = new byte[StorageSize];
state.ThreadHandle.Set();
}
public void PutInNewItem(Action <object> action, object o)
{
ThreadParams param = new ThreadParams()
{
Action = action, Parameter = o
};
threadPool.Enqueue(param);
}
private void EnqueueThreadItem(object threadParams)
{
ThreadParams param = threadParams as ThreadParams;
//param.Action(param.Parameter);
ThreadPool.QueueUserWorkItem(new WaitCallback(param.Action), param.Parameter);//由于客户端与服务端数据交互较频繁，用线程池进行每次通信任务的处理
//Thread thread = new Thread(new ParameterizedThreadStart(param.Action));
//thread.Start(param.Parameter);
//thread.Join();
}
public void InitializeCloud()
{
visibleClouds = new int[CloudSystem.instance.maxClouds];
visibleParticles = new int[CloudSystem.instance.maxParticles];
maxMeshParticles = CloudSystem.instance.maxParticles / 4;
vertices = new Vector3[maxMeshParticles * 4];
colors = new Color32[maxMeshParticles * 4];
particleSort = new ParticleSort[CloudSystem.instance.maxParticles];
myThreads = new int[CloudSystem.instance.maxThreadCount];
if (helperThreads == null)
{
helperThreads = new Thread[CloudSystem.instance.maxThreadCount];
helperParams = new ThreadParams[CloudSystem.instance.maxThreadCount];
for (int i = 0; i < CloudSystem.instance.maxThreadCount; i++)
{
helperThreads[i] = new Thread(Worker);
helperParams[i] = new ThreadParams
{
start = maxMeshParticles / CloudSystem.instance.threadCount * (i % CloudSystem.instance.threadCount),
end = maxMeshParticles / CloudSystem.instance.threadCount * (i % CloudSystem.instance.threadCount + 1),
running = (i < CloudSystem.instance.threadCount),
abort = false,
verts = vertices,
cols = colors,
psort = particleSort,
vpCount = visibleParticlesCount,
startHandle = new AutoResetEvent(initialState: false),
completeHandle = new AutoResetEvent(initialState: false)
};
myThreads[i] = ((i >= CloudSystem.instance.threadCount) ? (-1) : i);
helperThreads[i].Start(helperParams[i]);
}
return;
}
for (int j = 0; j < CloudSystem.instance.threadCount; j++)
{
myThreads[j] = -1;
for (int k = 0; k < CloudSystem.instance.maxThreadCount; k++)
{
if (!helperParams[k].running)
{
helperParams[k].start = maxMeshParticles / CloudSystem.instance.threadCount * j;
helperParams[k].end = maxMeshParticles / CloudSystem.instance.threadCount * (j + 1);
helperParams[k].abort = false;
helperParams[k].verts = vertices;
helperParams[k].cols = colors;
helperParams[k].psort = particleSort;
helperParams[k].vpCount = visibleParticlesCount;
myThreads[j] = k;
helperParams[k].running = true;
break;
}
}
}
}
// NOTE: Process "hg" is not in list, because it causes only low CPU load
public static void StartController(ProcessPriorityClass priority, OutputManager outputManager)
{
ThreadParams threadParams = new ThreadParams(priority, outputManager);
Thread controllerThread = new Thread(new ParameterizedThreadStart(ControlThread.DoWork));
controllerThread.IsBackground = true; // stop thread when main thread stops
controllerThread.Start(threadParams);
outputManager.Info("Priority for worker processes: " + priority.ToString());
}
private void ExecuteThreadPool()
{
//custom thread parameter object
ThreadParams tParams = new ThreadParams();
//get the file name from command prompt - user input
tParams.sourceFileName = labelFilePath.Text;
//queue the file copy thread for execution
ThreadPool.QueueUserWorkItem(new WaitCallback(readFileThreadPool), tParams);
}
private static void ThreadActivateTheme(object param)
{
if (!(param is ThreadParams))
{
Log.Error("param at ThreadActivateTheme has wrong type");
return;
}
ThreadParams threadParams = (ThreadParams)param;
GUIWaitCursor.Show();
// Need to initialize fonts and references if they change based on the theme.
// Check current theme.
bool initFonts = (GUIGraphicsContext.HasThemeSpecificSkinFile(@"\fonts.xml"));
bool initReferences = (GUIGraphicsContext.HasThemeSpecificSkinFile(@"\references.xml"));
// Change the theme and save this new setting.
SetTheme(threadParams._themeName);
SkinSettings.Save();
// Check new theme.
initFonts = initFonts || GUIGraphicsContext.HasThemeSpecificSkinFile(@"\fonts.xml");
initReferences = initReferences || GUIGraphicsContext.HasThemeSpecificSkinFile(@"\references.xml");
// Reset fonts if needed.
if (initFonts)
{
// Reinitializing the device while changing fonts freezes the UI.
// Add some sleep() to present the wait cursor animation for at least some user feedback.
Thread.Sleep(500);
GUIFontManager.ClearFontCache();
GUIFontManager.LoadFonts(GUIGraphicsContext.GetThemedSkinFile(@"\fonts.xml"));
GUIFontManager.InitializeDeviceObjects();
Thread.Sleep(500);
}
// Force a reload of the control references if needed.
if (initReferences)
{
GUIControlFactory.ClearReferences();
}
// Reactivate the current window and refocus on the control used to change the theme.
// This applies the new theme to the current window immediately.
GUIWindowManager.ResetAllControls();
GUIWindowManager.SendThreadCallbackAndWait((p1, p2, p3) =>
{
GUIWindowManager.ActivateWindow(p1, true, true, (int)p3);
return(0);
}, GUIWindowManager.ActiveWindow, 0, threadParams._focusControlId);
GUIWaitCursor.Hide();
}
public async Task <PagedList <Message> > GetMessageThread(int requestorId, ThreadParams threadParams)
{
var messagesThread = _context.Messages.Where(x =>
(x.RecipientId == requestorId && x.SenderId == threadParams.SecondUserId) ||
(x.RecipientId == threadParams.SecondUserId && x.SenderId == requestorId))
.Include(x => x.Sender)
.Include(x => x.Recipient)
.OrderByDescending(x => x.MessageSent);
var massage = await messagesThread.ToListAsync();
return(await PagedList <Message> .CreateAsync(messagesThread, threadParams.PageNumber, threadParams.PageSize));
}
private void ExecuteTask()
{
ThreadParams p = (ThreadParams)_params;
if (p.isPOST)
{
p.outStatus = _webExchange.HttpPost(p.hostName, p.model, p.deviceID, p.action, p.file, out p.outResponse, p.timeout);
}
else
{
p.outStatus = _webExchange.HttpGet(p.hostName, p.model, p.deviceID, p.action, out p.outResponse, p.extraParams, p.timeout);
}
_isDone.Set();
}
void CalculatePopulationFitnessNonThreaded()
{
ResetFitnessValue();
battles = 0;
ThreadParams threadParams = new ThreadParams(0, populationSize - 1);
threadParams.currentHandle = new ManualResetEvent(false);
BattleWork(threadParams);
//Sort highest fitness value to lowest
population.Sort((creatureA, creatureB) => creatureB.fitnessValue.CompareTo(creatureA.fitnessValue));
totalFitness = battles;
}
public static string ActivateThemeByName(string themeName, int focusControlId)
{
// Change themes in a background thread so that the wait cursor gets presented during the theme change.
ThreadParams threadParams = new ThreadParams()
{
_themeName = themeName, _focusControlId = focusControlId
};
Thread ActivateThemeThread = new Thread(new ParameterizedThreadStart(ThreadActivateTheme));
ActivateThemeThread.Name = "Activate theme for skin";
ActivateThemeThread.IsBackground = true;
ActivateThemeThread.Priority = ThreadPriority.Normal;
ActivateThemeThread.Start(threadParams);
return(themeName);
}
static void DoWork(object param)
{
ThreadParams _params = param as ThreadParams;
string _imageUrl = _params.ImageUrl;
if (string.IsNullOrEmpty(_imageUrl))
{
return;
}
bool _doIt = true;
if (_params.Movie != null)
{
// if the ResultMovieItem needs to do something before querying data...execute and wait for event
if (_params.Movie.DataQuerying != null)
{
_params.Movie.DataQuerying(_params.Movie, new EventArgs());
}
// if Movie has DataReady event not null, wait for it (max 10 seconds)
if (_params.Movie.DataReadyEvent != null)
{
_doIt = _params.Movie.DataReadyEvent.WaitOne(10000);
_params.Movie.DataReadyEvent = null;
}
}
BitmapImage _bmp = null;
if (_doIt)
{
_bmp = DownloadImageFromUrl(_imageUrl);
}
_params.Dispatcher.Dispatcher.BeginInvoke((Action) delegate
{
if (_params.Handler != null)
{
try
{
_params.Handler(_bmp, _params.ImageUrl, _params.Dispatcher);
}
catch { }
}
}, DispatcherPriority.Normal);
}
public static void CalculatePartitionResult(object stateParams)
{
ThreadParams thrParams = (ThreadParams)stateParams;
int start = thrParams.start;
int end = thrParams.end;
int n = thrParams.nCount;
AngryComboDict dict = thrParams.dict;
long count = 0;//thrParams.Count;
for (int i = start; i <= end; i++)
{
// lstSafeCombinations.Add(new List<string>());
bool skipAhead = false;
// string items = "";
for (int j = i + 1; j <= n; j++)
{
//for(int k=i; k < j; k++)
//{
//if (!dict.KeyExists(k))
//{
// break;
//}
//find limit between i and j so that it can be verified and loop is skipped
if (dict.KeyValuePairExistsMinMax(j, i))
{
skipAhead = true;
break;
}
//}
if (!skipAhead)
{
count = count + 1;
// lstSafeCombinations[i - 1].Add("--"+j.ToString());
}
else
{
break;
}
}
}
thrParams.Count = count;
}
// constructor, will start worker handling
public HandleWorkers(int min, int max, int batchSize, string fileName, bool lower, bool upper, bool numbers, bool symbols)
{
isReady = false;
lowerChars = lower;
upperChars = upper;
numberChars = numbers;
symbolChars = symbols;
validChars = new List <char>();
if (lower)
{
validChars.AddRange(BreakPass.lowerCaseChars);
}
if (upper)
{
validChars.AddRange(BreakPass.upperCaseChars);
}
if (numbers)
{
validChars.AddRange(BreakPass.numberChars);
}
if (symbols)
{
validChars.AddRange(BreakPass.symbolChars);
}
batchesNotProcessed = new ConcurrentBag <Tuple <char[], char[]> >();
batchesProcessed = new ConcurrentBag <Tuple <char[], char[]> >();
bathcesProcessing = new ConcurrentBag <Tuple <char[], char[]> >();
ThreadParams p = new ThreadParams();
p.min = min;
p.max = max;
p.batchSize = batchSize;
Thread splitThread = new Thread(new ParameterizedThreadStart(SplitBatchThread));
splitThread.SetApartmentState(ApartmentState.STA);
splitThread.Start(p);
doWork = true;
workThread = new Thread(new ParameterizedThreadStart(DoWorkThread));
workThread.Start(fileName);
}
private void Listen <T>(object obj) where T : class
{
if (obj == null)
{
throw new ArgumentNullException();
}
ThreadParams <T> param = obj as ThreadParams <T>;
if (param == null)
{
throw new InvalidCastException("Cannot cast " + obj + " to ThreadParams<" + typeof(T) + ">");
}
try
{
while (true)
{
Console.WriteLine("Waiting for a connection via port {0}", ipEndPoint);
Socket handler = serverSocket.Accept();
Console.WriteLine("Server set connection with {0}", handler.LocalEndPoint);
byte[] bytes = new byte[config.BufferSize];
int bytesRecieved;
T data = null;
while (handler.Available > 0)
{
bytesRecieved = handler.Receive(bytes);
data = param.store(bytes, bytesRecieved, data);
}
beforeDataManipulates();
data = param.action(data);
afterDataManipulates();
if (param.closeConnectionCondition(data))
{
Console.WriteLine("Server closed the connection with client: {0}", handler.LocalEndPoint);
onCloseConnection();
handler.Shutdown(SocketShutdown.Both);
handler.Close();
}
}
}
catch (ThreadAbortException e)
{
Console.WriteLine(e.ExceptionState);
onStop();
}
}
/// <summary>
/// Decodes entities to be of the given type by using a list of json strings and a type
/// It is Multithreaded for faster efficiency
/// </summary>
/// <param name="json">A list of json strings</param>
/// <param name="type">the entity type (case insensitive)</param>
/// <returns>An array of entities built from JSON</returns>
#else
/// <summary>
/// Decodes entities to be of the given type by using a list of json strings and a type
/// </summary>
/// <param name="json">A list of json strings</param>
/// <param name="type">the entity type (case insensitive)</param>
/// <returns>An array of entities built from JSON</returns>
#endif
public static Entity[] Decode(List<String> json, String type)
{
Entity[] entities = new Entity[json.Count];
CreateEntity entityCreator = GetEntityCreator(type);
int index = 0;
#if THREAD_SAFE
Thread[] threads = new Thread[json.Count];
ThreadParams[] threadParams = new ThreadParams[json.Count];
#endif
foreach (String j in json)
{
#if THREAD_SAFE
ThreadParams param = new ThreadParams();
threadParams[index] = param;
param.json = j;
param.createFunc = entityCreator;
threads[index] = StartThread(param);
#else
JsonDeserializer deserializer = new JsonDeserializer();
entities[index] = entityCreator(j, deserializer);
#endif
++index;
}
#if THREAD_SAFE
for(index = 0; index < threads.Length; ++index)
{
threads[index].Join();
entities[index] = threadParams[index].entity;
}
#endif
return entities;
}
/// <summary>
/// Search files asynchronously
/// </summary>
/// <param name="folder">The folder where to begin searching.</param>
/// <param name="pattern">The pattern the files need to match (ex. *.txt).</param>
/// <param name="includeSubfolders">Specifies whether or not to search the subfolders.</param>
public void SearchFilesAsync(string folder, string pattern, bool regexPattern, bool includeSubfolders)
{
Thread t = new Thread(SearchAsync);
t.Name = "SearchThread";
ThreadParams param = new ThreadParams();
param.folder = folder;
param.pattern = pattern;
param.regexPattern = regexPattern;
param.includeSubfolders = includeSubfolders;
t.Priority = ThreadPriority.BelowNormal;
t.Start(param);
}
public static void ApplyOptions(MainViewModel model, bool ApplyingToCurrentUserAsAdmin = false)
{
bool IsAdminUser = (model.AppModel.IsAdmin && !ApplyingToCurrentUserAsAdmin);
Thread th = new Thread(new ParameterizedThreadStart(ApplyOptionsThreadProc));
th.SetApartmentState(ApartmentState.STA);
var threadParams = new ThreadParams()
{
model = model,
IsAdmin = IsAdminUser
};
th.Start(threadParams);
th.Join();
// marshal the exception back to the UI thread - up to calling code to deal with it.
if (threadParams.Exception != null)
throw threadParams.Exception;
}
/// <summary>
/// This starts a new thread that will parse and create an object; useful for large objects/json
/// by having this in it's own function, the lambda function will use the function closure to get the correct variables
/// </summary>
/// <param name="param">The thread params to use</param>
/// <returns>The thread that was started</returns>
private static Thread StartThread(ThreadParams param)
{
Thread t = new Thread(() => { param.entity = param.createFunc(param.json, new JsonDeserializer()); });
t.Start();
return t;
}
protected void StartImport(WebEPG.ShowProgressHandler showProgress)
{
if (_workerThreadRunning)
return;
_workerThreadRunning = true;
ThreadParams param = new ThreadParams();
param.showProgress = showProgress;
Thread workerThread = new Thread(new ParameterizedThreadStart(ThreadFunctionImportTVGuide));
workerThread.Name = "WebEPGImporter";
workerThread.IsBackground = true;
workerThread.Priority = ThreadPriority.Lowest;
workerThread.Start(param);
}
/// <summary>
/// Forces the import of the tvguide. Usable when testing the grabber
/// </summary>
/// <param name="folder">The folder where tvguide.xml or tvguide.lst is stored</param>
/// <param name="importXML">True to import tvguide.xml</param>
/// <param name="importLST">True to import files in tvguide.lst</param>
public void ForceImport(String folder, bool importXML, bool importLST)
{
string fileName = folder + @"\tvguide.xml";
if (System.IO.File.Exists(fileName) && importXML)
{
importXML = true;
}
fileName = folder + @"\tvguide.lst";
if (importLST && System.IO.File.Exists(fileName))
{
DateTime fileTime = DateTime.Parse(System.IO.File.GetLastWriteTime(fileName).ToString());
// for rounding errors!!!
importLST = true;
}
if (importXML || importLST)
{
ThreadParams tp = new ThreadParams();
tp._importDate = DateTime.MinValue;
tp._importLST = importLST;
tp._importXML = importXML;
this.ThreadFunctionImportTVGuide(tp);
}
}
protected void StartImport(bool importXML, bool importLST, DateTime importDate)
{
FileStream streamIn = null;
StreamReader fileIn = null;
if (_workerThreadRunning)
return;
TvBusinessLayer layer = new TvBusinessLayer();
string folder = layer.GetSetting("xmlTv", DefaultOutputFolder).Value;
Thread.Sleep(500); // give time to the external prog to close file handle
if (importXML)
{
string fileName = folder + @"\tvguide.xml";
try
{
//check if file can be opened for reading....
IOUtil.CheckFileAccessRights(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
}
catch (Exception e)
{
Log.Error(@"plugin:xmltv StartImport - File [" + fileName + "] doesn't have read access : " + e.Message);
return;
}
}
if (importLST)
{
string fileName = folder + @"\tvguide.lst";
try
{
IOUtil.CheckFileAccessRights(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
}
catch (Exception e)
{
Log.Error(@"plugin:xmltv StartImport - File [" + fileName + "] doesn't have read access : " + e.Message);
return;
}
try //Check that all listed files can be read before starting import (and deleting programs list)
{
Encoding fileEncoding = Encoding.Default;
streamIn = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
fileIn = new StreamReader(streamIn, fileEncoding, true);
while (!fileIn.EndOfStream)
{
string tvguideFileName = fileIn.ReadLine();
if (tvguideFileName.Length == 0) continue;
if (!System.IO.Path.IsPathRooted(tvguideFileName))
{
// extend by directory
tvguideFileName = System.IO.Path.Combine(folder, tvguideFileName);
}
try
{
IOUtil.CheckFileAccessRights(tvguideFileName, FileMode.Open, FileAccess.Read, FileShare.Read);
}
catch (Exception e)
{
Log.Error(@"plugin:xmltv StartImport - File [" + tvguideFileName + "] doesn't have read access : " +
e.Message);
return;
}
}
}
finally
{
if (streamIn != null)
{
streamIn.Close();
streamIn.Dispose();
}
if (fileIn != null)
{
fileIn.Close();
fileIn.Dispose();
}
}
}
_workerThreadRunning = true;
ThreadParams param = new ThreadParams();
param._importXML = importXML;
param._importLST = importLST;
param._importDate = importDate;
Thread workerThread = new Thread(new ParameterizedThreadStart(ThreadFunctionImportTVGuide));
workerThread.Name = "XmlTvImporter";
workerThread.IsBackground = true;
workerThread.Priority = ThreadPriority.Lowest;
workerThread.Start(param);
}
