我有一个运行的foreach循环.我正在研究并行功能.是否可以转换以下代码以使用并行编程？
int result ;
int counter;
foreach(DataRow dr in ds.Tables[0].Rows) {
switch(dr["Gender"].ToString()) {
case "Male":
result = functionMale(dr["Gender"].ToString());
counter += result;
break;
case "Female":
result = functionFemale(dr["Gender"].ToString());
counter += result;
break;
default:
result = functionUnkown(dr["Gender"].ToString());
counter += result;
break;
}
}
根据我的观察,我到目前为止只有以下内容.
Parallel.ForEach(ds.Tables[0].AsEnumerable(), dr => {
var result = functionMale(dr["Gender"].ToString();
});
有任何想法吗？谢谢
我有以下C#代码:
1. List<BandEdge> bandEdgeList;
2.
3. bandEdgeList = CicApplication.BandEdgeCache.Where(row => row.Coater == coater).ToList();
4. foreach (BandEdge bandEdge in bandEdgeList)
5. {
6. ...
7. ...
8. }
我的问题是这个.一旦'bandEdgeList'填充在第3行,如果另一个线程修改了CicApplication.BandEdgeCache的内容,'bandEdgeList'的内容是否会失效？我在CicApplication.BandEdgeCache getter/setter中有一个锁.但是我想知道是否应该锁定这段代码,以便在我使用'bandEdgeList'时CicApplication.BandEdgeCache的内容不会改变.
我不确定是否已经存在这样的术语,但是为了这个问题,我们定义两个术语:对等实现或嵌套实现来说明如何在包含许多父/子实体关系的数据模型中实现集合类.
我使用术语peer来描述你在模型层中实现集合类的场景,以及实体类本质上使它们在你的API中成为对等体,如下所示:
public class ParentEntity
{
private ChildEntityCollection children;
}
public class ChildEntity
{
}
public class ChildEntityCollection : ICollection<ChildEntity>
{
}
这里的主要优点是您可以在碰巧存储相同类型子级的其他实体类中重用该集合类.
我使用术语嵌套来描述你将它们实现为嵌套类的场景,如下所示:
public class ParentEntity
{
private ChildEntityCollection children;
public class ChildEntityCollection : ICollection<ChildEntity>
{
}
}
public class ChildEntity
{
}
这里的主要优点是每个父级都可以实现自己的集合类,以最适合该特定父级的方式存储其子级.例如,一个父实体可能会发现一个数组数据结构运行良好而另一个可能使用一个splay树(我知道这个模糊不清,但它很好地说明了我的观点).
我注意到Microsoft在各种.NET相关框架中使用了这两种习惯用法.System.Windows.Forms命名空间似乎很大程度上依赖于嵌套实现.我倾向于发现自己也喜欢这种方法,即使它需要更多的工作.
建议,评论,替代想法？
你会如何使用C#中最新的线程技术重写它？
var dateRange = new DateRange(date, date.AddDays(1));
var extracter = new ConversionsExtracter(dateRange, AdvertiserId);
var loader = new ConversionsLoader();
var extracterThread = extracter.Start();
var loaderThread = loader.Start(extracter);
extracterThread.Join();
loaderThread.Join();
loader和extract对象都有一个Start方法:
public Thread Start()
{
var thread = new Thread(Extract);
thread.Start();
return thread;
}
(我知道他们没有,但我正在寻找其实际工作的根本原因,而不使用volatile,因为没有什么可以防止编译器将变量存储在没有volatile的寄存器中......或者是......)
这个问题源于思想的不和谐,即没有易失性的编译器(理论上可以通过各种方式优化任何变量,包括将其存储在CPU寄存器中.)虽然文档说在使用锁定变量等同步时不需要.但实际上在某些情况下,编译器/ jit似乎无法知道您是否会在代码路径中使用它们.所以怀疑是在这里真正发生的事情,使记忆模型"工作".
在这个例子中,什么阻止编译器/ jit优化_count到一个寄存器,从而在寄存器上完成增量而不是直接到存储器(稍后在退出调用后写入内存)？如果_count是易变的,那么看起来一切都应该没问题,但很多代码都是在没有volatile的情况下编写的.如果在方法中看到锁定或同步对象,编译器可能知道不会将_count优化到寄存器中,但在这种情况下,锁定调用是在另一个函数中.
大多数文档都说如果使用锁等同步调用,则不需要使用volatile.
那么是什么阻止了编译器优化_count到寄存器并可能只更新锁中的寄存器？我有一种感觉,大多数成员变量都不会因为这个原因被优化到寄存器中,因为每个成员变量都需要是易变的,除非编译器告诉它不应该优化(否则我怀疑大量的代码会失败) .我看到类似的东西,看看C++多年前本地函数变量存储在寄存器中,类成员变量没有.
所以主要的问题是,它是否真的是没有volatile的唯一方法,编译器/ jit不会将类成员变量放在寄存器中,因此不需要volatile？
(请忽略调用中缺少异常处理和安全性,但你得到了要点.)
public class MyClass
{
object _o=new object();
int _count=0;
public void Increment()
{
Enter();
// ... many usages of count here...
count++;
Exit();
}
//lets pretend these functions are too big to inline and even call other methods
// that actually make the monitor call (for example a base class that implemented these)
private void Enter() { Monitor.Enter(_o); }
private void Exit() { Monitor.Exit(_o); } //lets pretend this function …我有这个代码:
private STOP = false;
public void Start()
{
while(!STOP)
{
//do some work
Thread.Sleep(15000);
}
}
public void Stop()
{
STOP = true;
}
但使用此代码有时需要等待15秒,如何快速停止此循环或者可能需要使用其他代码？
谢谢!
我有一个Windows窗体.单击"确定"时,将完成一些工作,这需要一些时间.在此过程中,窗体的所有控件都被禁用,因此用户无法执行某些操作.除了一个按钮,中止.此按钮仍可用于中止过程任务.我开始一个新线程,很好.问题是当单击ob abort时,在线程结束后调用该事件.
下面是代码来启动线程(在我的buttonOk_Click Eventmethod中)(我正在使用优先级来假装在我做一些数据库操作时中止线程):
t1 = new System.Threading.Thread(processing);
t1.Priority = System.Threading.ThreadPriority.Normal;
t1.Start();
下面是我捕获中止事件的代码,但是在线程工作期间没有访问它.(使用ButtonAbort_Click-Method)
while (t1.Priority == System.Threading.ThreadPriority.Highest)
{
System.Threading.Thread.Sleep(1000);
}
try
{
lock (t1)
{
if (t1.ThreadState != System.Threading.ThreadState.Aborted)
{
//abort Thread
t1.Abort();
//wait that lock is not released to early
while (t1.ThreadState != System.Threading.ThreadState.Aborted) { }
}
}
}
希望您能够帮助我.谢谢.
在我的主要表单中,我运行这个:
this.disableForm();
btnAbort.Enabled = true;
disableForm是我的程序中Form的扩展方法,定义如下:
public static void disableForm(this Form f)
{
foreach (Control c in f.Controls)
{
f.Enabled = false;
}
f.Cursor = Cursors.WaitCursor;
}
问题是下一个命令btnAbort.Enabled = true;没有做任何事情.
如果我将代码直接放在方法中而不是调用,它就可以工作disableForm().为什么会这样？它与线程有关吗？
我有这个字符串MIL_A_OP=LI_AND=SSB12=JL45==DO=90==IT=KR002112
,我需要将它拆分为2,基于第一个"="
所以我需要它得到:
第一个字符串 MIL_A_OP
第二串: LI_AND=SSB12=JL45==DO=90==IT
这下面的代码是我的,但它给了我MIL_A_OP和LI_AND,我想念其余的
try
{
StreamReader file1 = new StreamReader(args[0]);
string line1;
while ((line1 = file1.ReadLine()) != null)
{
if (line1 != null && line1.Trim().Length > 0)//if line is not empty
{
int position_1 = line1.IndexOf('=');
string s_position_1 = line1.Substring(position_1, 1);
char[] c_position_1 = s_position_1.ToCharArray(0,1);
string[] line_split1 = line1.Split(c_position_1[0]);
Foo.f1.Add(line_split1[0], line_split1[1]);
}
}
file1.Close();
}
catch (Exception e)
{
Console.WriteLine("File " + args[0] + " could not be read");
Console.WriteLine(e.Message);
}
Thread t = new Thread (WriteY);
t.Start();
for (int i = 0; i < 1000; i++) Console.Write ("x");
static void WriteY()
{
for (int i = 0; i < 1000; i++) Console.Write ("y");
}
内部线程如何工作？意味着为什么每次运行时上述代码的输出都没有修复,'x'和'y'的顺序是不同的？
我试图第一次使用线程,并想出了这个:
Thread myThread = new Thread(() =>
{
test = Class1.getNumbers(param1, param 2);
MessageBox.Show(test.toString());
});
但这对我没有任何帮助.我做错了什么？
c# ×12
.net ×3
winforms ×3
asp.net ×1
collections ×1
concurrency ×1
locking ×1
nested-class ×1
split ×1
string ×1
volatile ×1
while-loop ×1