public ServiceResult <bool> PreperationFinished(int threadID)
{
var result = new ServiceResult <bool>()
{
Success = true
};
try
{
Thread thread = ThreadList.Find(t => t.GetHashCode() == threadID);
if (thread != null)
{
result.Data = !thread.IsAlive;
}
else
{
throw new Exception("Thread with ID " + threadID + " not found!");
}
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.Message;
}
return(result);
}
public void StartAccepting()
{
Socket listenSocket = null;
var builder = new StringBuilder();
var bytesReceived = 0;
var lengthBuffer = new byte[1];
while (true)
{
listenSocket = ObjSocket.Accept();
Console.Write("New Connection: ");
bytesReceived = listenSocket.Receive(lengthBuffer);
var buffer = new byte[lengthBuffer[0]];
bytesReceived = listenSocket.Receive(buffer);
builder.Clear();
builder.Append(Encoding.ASCII.GetString(buffer), 0, bytesReceived);
Console.WriteLine(builder);
ClientList.Add(listenSocket, Encoding.ASCII.GetString(buffer));
ThreadList.Add(listenSocket, new Thread(delegate() { Server.MessageHandler(this, listenSocket); }));
ThreadList[listenSocket].Start();
}
}
public ServiceResult <int> WatermarkFile(byte[] msFile, string sUsername, string sCompany)
{
var result = new ServiceResult <int>()
{
Success = true
};
try
{
DelWatermarkedFile delWatermarkedFile = new DelWatermarkedFile(delReturnFile);
PrepareFileThread pft = new PrepareFileThread(new MemoryStream(msFile), delWatermarkedFile, sUsername, sCompany);
Thread thread = new Thread(new ThreadStart(pft.Start));
thread.Start();
if (ThreadList == null)
{
ThreadList = new List <Thread>();
}
result.Data = thread.GetHashCode();
ThreadList.Add(thread);
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.Message;
}
return(result);
}
/// <summary>
/// Get Forum Page Info.
/// </summary>
/// <param name="document">The SA Forum Page.</param>
/// <param name="threadList">The Forum Thread List.</param>
/// <returns>A Forum Thread List with Updated Info.</returns>
public static ThreadList GetForumPageInfo(IHtmlDocument document, ThreadList threadList)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
if (threadList == null)
{
throw new ArgumentNullException(nameof(threadList));
}
var pages = document.QuerySelector(".pages");
if (pages == null)
{
return(threadList);
}
var select = pages.QuerySelector("select");
var selectedPageItem = select.QuerySelector("option:checked");
threadList.CurrentPage = Convert.ToInt32(selectedPageItem.TextContent, CultureInfo.InvariantCulture);
threadList.TotalPages = select.ChildElementCount;
return(threadList);
}
public void Add(Thread thr)
{
var tl = new ThreadList(thr);
tl.next = this.next;
this.next = tl;
}
// *********************************************************************
// InitializeSkin
//
/// <summary>
/// Initializes the user control loaded in CreateChildControls. Initialization
/// consists of finding well known control names and wiring up any necessary events.
/// </summary>
///
// ********************************************************************/
override protected void InitializeSkin(Control skin)
{
// Ensure we have a valid forum
try {
forum = Forums.GetForumInfo(ForumID);
} catch (Components.ForumNotFoundException) {
Page.Response.Redirect(Globals.UrlMessage + Convert.ToInt32(Messages.UnknownForum));
Page.Response.End();
}
// Find the forum name
forumName = (HyperLink)skin.FindControl("ForumName");
if (forumName != null)
{
forumName.Text = forum.Name;
forumName.NavigateUrl = Globals.UrlShowForum + ForumID;
}
// Find the forum Description
forumDescription = (Label)skin.FindControl("ForumDescription");
if (forumDescription != null)
{
forumDescription.Text = forum.Description;
}
// Find the thread list
threadList = (ThreadList)skin.FindControl("ThreadList");
}
/// <summary>
/// Binds the threads from the database to the list control
/// </summary>
/// <param name="ItemID">itemID of ANY of the topics in the thread</param>
private void BindList(int ItemID)
{
// Obtain a list of discussion messages for the module and bind to datalist
DiscussionDB discuss = new DiscussionDB();
ThreadList.DataSource = discuss.GetThreadMessages(ItemID, 'Y'); // 'Y' means include rootmessage
ThreadList.DataBind();
}
//-------------------------------------------------------------
// 概要：次スレ候補を取得する
//-------------------------------------------------------------
public bool ChangeCandidateThread()
{
if (SelectThread.ThreadNo != null)
{
var openedThreads = new List <string>();
Func <bool> f = () =>
{
// 現在のスレッドタイトル名に数字が含まれていれば次のスレ番のスレを探す
var regex = new Regex(@"(\d+)");
var compare = CultureInfo.CurrentCulture.CompareInfo;
foreach (Match match in regex.Matches(SelectThread.ThreadTitle))
{
var number = TextUtil.FullWidthToHalfWidth(match.Captures[0].Value);
var nextNumber = int.Parse(number) + 1;
var threads = ThreadList.Where(info =>
compare.IndexOf(info.ThreadTitle, nextNumber.ToString(), CompareOptions.IgnoreWidth) != -1)
.Where(x => !openedThreads.Contains(x.ThreadNo))
.OrderByDescending(info => info.ThreadSpeed);
if (!threads.Any())
{
continue;
}
ChangeThread(threads.First().ThreadNo);
openedThreads.Add(threads.First().ThreadNo);
return(true);
}
return(false);
};
for (;;)
{
// 次スレが見つからない場合ループを抜ける
if (!f())
{
break;
}
// 埋まっていないスレになったら終わり
if (!SelectThread.IsStopThread)
{
return(true);
}
}
}
// 埋まっていないスレかつ
// スレが選択されていれば、現在のスレより新しいスレかつ
// 勢いの高いスレを選ぶ
var threads2 = ThreadList.Where(info => !info.IsStopThread)
.Where(info => !ThreadSelected || int.Parse(BbsInfo.ThreadNo) < int.Parse(info.ThreadNo))
.OrderByDescending(info => info.ThreadSpeed);
// 候補スレッドが無ければ終わり
if (!threads2.Any())
{
return(false);
}
ChangeThread(threads2.First().ThreadNo);
return(true);
}
private void UpdateThreadList(ThreadList sender)
{
threadsListView.BeginUpdate();
threadsListView.Items.Clear();
foreach (Thread thread in debugger.ThreadList) {
threadsListView.Items.Add("Thread A");
}
threadsListView.EndUpdate();
}
static void Main(string[] args)
{
var pool = new ThreadList();
var output = pool.ProcessPool();
Console.WriteLine(output);
Console.ReadLine();
}
public ActionResult Search(string searchTerms)
{
var threads = new ThreadList
{
Threads = this.GetSearchResults(this.CurrentUser, searchTerms, true).OrderByDescending(t => t.LastPostDate)
};
return(View("Search", threads));
}
public ThreadListViewModel(SingleProcess process)
{
ProcessLabel = $"Process: {process.Id} {process.Name}";
_threadList = new ObservableCollection <SingleThread>();
foreach (ProcessThread processThread in process.ThreadList)
{
ThreadList.Add(new SingleThread(processThread, process.Accessible));
}
}
public ActionResult ViewForum(long?id, int?page)
{
int pageSize = 25;
if (!id.HasValue)
{
return(View("NotAvailable"));
}
Forum f = this.Forums.GetForum(id.Value);
if (f == null)
{
return(View("NotFound"));
}
ForumAccess a = this.Security.GetUserForumAccess(CurrentUser, f);
if (!a.CanView)
{
return(View("NotAuthorized"));
}
var threadSource = this.Forums.GetForumViewableThreads(f.ForumID);
var threadCount = threadSource.Count();
var threads = GetThreadInformation(threadSource, CurrentUser);
int pages = Pager.PageCount(threadCount, pageSize);
page = Pager.ClampPage(page, pages);
var threadsList = new ThreadList
{
Threads = threads.OrderByDescending(t => t.LastPostDate).OrderByDescending(t => t.Thread.Level).Skip((page.Value - 1) * pageSize).Take(pageSize).ToList()
};
var fd = new ForumDetailsModel
{
Forum = f,
UserAccess = a,
PageInfo = new PaginationInformation
{
Pager = this.Skins.GetDefaultForumPager(),
ControllerName = "Forums",
ActionName = "ViewForum",
PageAttribute = "page",
RouteValues = new System.Web.Routing.RouteValueDictionary(new { id = id }),
ItemsPerPage = pageSize,
Items = threadCount,
CurrentPage = page
},
Threads = threadsList
};
return(View("ViewForum", fd));
}
public Debugger(AsyncTaskRunner asyncTaskRunner) {
Dispatch.AsyncTaskRunner = asyncTaskRunner;
this.BreakpointList = new BreakpointList(this);
this.Memory = new Memory(this);
this.ModuleList = new ModuleList(this);
this.ThreadList = new ThreadList(this);
this.CurrentContext = new Context(this);
}
private void UpdateThreadList(ThreadList sender)
{
threadsListView.BeginUpdate();
threadsListView.Items.Clear();
foreach (Thread thread in debugger.ThreadList)
{
threadsListView.Items.Add("Thread A");
}
threadsListView.EndUpdate();
}
protected Scene()
{
_count = 0;
_seconds = 0;
_dateTime = DateTime.Now;
_loaded = false;
_toUpdate = new ThreadList <IUpdatable>();
_toDraw = new ThreadList <IDrawable>();
}
/// <summary>
/// Actual command logic
/// </summary>
/// <param name="source">The user who triggered the command.</param>
/// <param name="channel">The channel the command was triggered in.</param>
/// <param name="args">The arguments to the command.</param>
/// <returns></returns>
protected override CommandResponseHandler execute(User source, string channel, string[] args)
{
string[] statuses = ThreadList.instance().getAllThreadStatus();
CommandResponseHandler crh = new CommandResponseHandler();
foreach (string item in statuses)
{
crh.respond(item);
}
return(crh);
}
public void StopAll()
{
foreach (WorkerThread thread in ThreadList)
{
if (!IsDead(thread))
{
thread.Stop();
}
}
ThreadList.Clear();
}
protected Scene()
{
_count = 0;
_seconds = 0;
_dateTime = DateTime.Now;
_toUpdate = new ThreadList <IUpdatable>();
_toDraw = new ThreadList <IDrawable>();
_state = new SceneStateLoading();
}
public ThreadList <T> Clone()
{
BinaryFormatter Formatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.Clone));
MemoryStream stream = new MemoryStream();
Formatter.Serialize(stream, this);
stream.Position = 0;
ThreadList <T> clonedObj = Formatter.Deserialize(stream) as ThreadList <T>;
stream.Close();
return(clonedObj);
}
/// <summary>
/// Gets the list of threads in a given Forum.
/// </summary>
/// <param name="forumId">The Forum Id.</param>
/// <param name="page">The page of the forum to get.</param>
/// <param name="token">A CancellationToken.</param>
/// <returns>A ThreadList.</returns>
public async Task <ThreadList> GetForumThreadListAsync(int forumId, int page, CancellationToken token = default)
{
var pageUrl = string.Format(CultureInfo.InvariantCulture, EndPoints.ForumPage, forumId) + string.Format(CultureInfo.InvariantCulture, EndPoints.PageNumber, page);
var result = await this.webManager.GetDataAsync(pageUrl, token).ConfigureAwait(false);
var document = await this.webManager.Parser.ParseDocumentAsync(result.ResultHtml, token).ConfigureAwait(false);
var threadList = new ThreadList();
ForumHandler.GetForumPageInfo(document, threadList);
threadList.Threads.AddRange(ThreadHandler.ParseForumThreadList(document));
return(threadList);
}
/// <summary>
/// Adds a new Thread to the thread list and puts the thread in the waiting threads queue.
/// </summary>
/// <param name="start"></param>
public void Add(ThreadStart start)
{
var thread = new Thread(start);
lock (ThreadList)
{
ThreadList.Add(thread);
}
lock (WaitingThreads)
{
WaitingThreads.Enqueue(thread);
}
}
public override SceneState Load(ThreadList <IDrawable> drawList, ThreadList <IUpdatable> updateList,
Action onLoad)
{
var dateTime = DateTime.Now;
drawList.Clear();
updateList.Clear();
onLoad();
Logger.Print("Scene loaded with {0:f3} seconds", (DateTime.Now - dateTime).TotalSeconds);
return(new SceneStateLoaded());
}
public ActionResult ViewUnread()
{
if (this.CurrentUser == null)
{
return(RedirectToAction("Index"));
}
var tl = new ThreadList
{
Threads = GetUnreadThreads(CurrentUser).OrderByDescending(t => t.LastPostDate)
};
return(View("ViewUnread", tl));
}
public override void Update(float delta, ThreadList <IUpdatable> updateList, Action <float> onUpdate)
{
updateList.RemoveAll(DeleteIfDead);
try
{
updateList.ForEach(updatable => updatable.Update(delta));
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
}
onUpdate(delta);
}
/// <summary>
/// This call lets you get all the threads associated with a particular box.
/// </summary>
/// <param name="boxKey">The key of the box for which you want the threads listed</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">Please specify a pipeline key!</exception>
public ThreadList ListTasksInPipeline(string boxKey)
{
if (string.IsNullOrEmpty(boxKey))
{
throw new ArgumentNullException(nameof(boxKey), "Please specify a box key!");
}
var threadList = new ThreadList
{
RawApiResponse = _rawThreadServices.ListTasksInPipeline(boxKey)
};
threadList.Threads = JsonConvert.DeserializeObject <List <Thread> >(threadList.RawApiResponse.Json);
threadList.RawApiResponse = GetRawApiResponseOrNull(threadList.RawApiResponse);
return(threadList);
}
public override void Draw(Graphics graphics, ThreadList <IDrawable> drawList, Action <Graphics> onDraw)
{
drawList.RemoveAll(DeleteIfDead);
try
{
drawList.ForEach(drawable => drawable.Draw(graphics));
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
}
onDraw(graphics);
}
internal void Remove(Thread thread)
{
var prev = this;
ThreadList tl = this.next;
while (tl != null && tl.thr != thread)
{
prev = tl;
tl = tl.next;
}
if (tl != null)
{
prev.next = tl.next;
}
}
//-------------------------------------------------------------
// 概要：次スレ候補を取得する
//-------------------------------------------------------------
public bool ChangeCandidateThread()
{
// 埋まっていないスレかつ
// スレが選択されていれば、現在のスレより新しいスレかつ
// 勢いの高いスレを選ぶ
var threads = ThreadList.Where(info => !info.IsStopThread)
.Where(info => !ThreadSelected || int.Parse(BbsInfo.ThreadNo) < int.Parse(info.ThreadNo))
.OrderByDescending(info => info.ThreadSpeed);
// 候補スレッドが無ければ終わり
if (threads.Count() == 0)
{
return(false);
}
ChangeThread(threads.First().ThreadNo);
return(true);
}
public void StartNewThread(string JobName = "")
{
Thread NewThread = new Thread(() => ThreadAction(JobName)); // Function To Execute
NewThread.IsBackground = true;
int threadNum = 1; if (ThreadList != null)
{
threadNum = ThreadList.Count; threadNum++;
} // next available thread # to use
NewThread.Name = JobName + threadNum.ToString(); // unique thread name (jobname + next available num)
NewThread.Start();
ThreadList.Add(NewThread); // Save Thread to List of Running Threads
UpdateThreadStatusDisp(); // Update Gui with Thread Details
}
public IActionResult Scores()
{
var threadModel = _service.GetAll().Select(threads => new ThreadModel
{
Title = threads.Title,
Rating = threads.Votes,
Created = threads.CreateDate,
Picture = threads.Image,
Id = threads.ID,
Flagged = threads.Flagged,
AlbumId = threads.AlbumId
})
.OrderByDescending(x => x.Rating)
.ToList();
var threadList = new ThreadList {
ThreadLists = threadModel
};
return(View(threadList));
}
public void Start(Thread thread, string Name = "")
{
if (ThreadList == null)
{
ThreadList = new List <Thread>();
//ahk.MsgBox("Must Add \"Setup(); Reference To Initialize ThreadList First");
//return;
}
thread.IsBackground = true;
if (Name != "")
{
thread.Name = Name;
}
thread.Start();
ThreadList.Add(thread); // Save Thread to List of Running Threads
TelTreeDisp();
}
public static ThreadList CreateSentinal()
{
var tl = new ThreadList(null);
return tl;
}
public OperatingSystem(IScheduler scheduler)
{
Scheduler = scheduler;
Processes = new ProcessList();
Threads = new ThreadList();
}
public void Add(Thread thr)
{
var tl = new ThreadList(thr);
tl.next = this.next;
this.next = tl;
}
