C#:如何使IEnumerable <T>线程安全？
在C#中，要使IEnumerable<T>线程安全，可以使用以下方法：
- 使用
lock关键字：
private readonly object _lock = new object();
private IEnumerable<T> _items;
public void AddItem(T item)
{
lock (_lock)
{
var list = _items.ToList();
list.Add(item);
_items = list.AsEnumerable();
}
}
public IEnumerator<T> GetEnumerator()
{
lock (_lock)
{
return _items.GetEnumerator();
}
}- 使用
ConcurrentBag<T>：
private ConcurrentBag<T> _items = new ConcurrentBag<T>();
public void AddItem(T item)
{
_items.Add(item);
}
public IEnumerator<T> GetEnumerator()
{
return _items.GetEnumerator();
}- 使用
ReaderWriterLockSlim：
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
private IEnumerable<T> _items;
public void AddItem(T item)
{
_lock.EnterWriteLock();
try
{
var list = _items.ToList();
list.Add(item);
_items = list.AsEnumerable();
}
finally
{
_lock.ExitWriteLock();
}
}
public IEnumerator<T> GetEnumerator()
{
_lock.EnterReadLock();
try
{
return _items.GetEnumerator();
}
finally
{
_lock.ExitReadLock();
}
}推荐的腾讯云相关产品：
- Cloud Server：腾讯云云服务器提供高性能、稳定、安全、可扩展的计算服务，适用于各种应用场景。
- Cloud Object Storage：腾讯云对象存储为用户提供可扩展的数据存储服务，支持多种数据格式和应用场景。
- Cloud Database：腾讯云数据库提供稳定、安全、可扩展的数据库服务，支持多种数据库类型。
- Cloud Load Balancer：腾讯云负载均衡器可以帮助用户在多个服务器之间分配流量，提高应用程序的可用性和性能。
- Cloud CDN：腾讯云内容分发网络可以加速用户的网站访问速度，降低服务器负载，提高用户体验。
总结：
在C#中，要使IEnumerable<T>线程安全，可以使用上述方法。每种方法都有其优缺点，具体选择哪种方法取决于具体的应用场景和性能要求。
相关·内容
3回答
我有一个IEnumerable<T>源代码，它需要时间来生成每个项目。一旦生成一个项，我希望缓存它，以避免重新计算相同的东西。我想将缓存逻辑从原始源中分离出来。
困扰我的几件事是：
我应该在哪里买_cache？在CachedEnumerable还是CacheEnumerator？
添加到缓存中的线程安全性。
重新创造？任何现有的.NET或其他库都是这样做的。
为什么Dispose in IEnumerator？我应该在那里做点什么吗？_cache核弹？
class CachedEnumerable<T> : IEnumerable<T>
{
priv
浏览 0提问于2012-05-05得票数 6
2回答
下面的静态方法线程安全吗？
、、、、
今天我在我们的代码库中发现了以下方法，它让我意识到它可能不是线程安全的。我认为IEnumerable可能是一个引用类型，并且可能在代码执行时被另一个线程修改。这是正确的吗，或者这个方法到底是线程安全的吗？如果不是，这个方法是静态的吗？似乎使它成为一个实例方法不会改变entities参数在另一个线程中被修改的可能性。
/// <summary>
/// Writes the Entity data in <paramref name="entities"/> to a CSV file located at <paramref name="p
浏览 1提问于2012-02-10得票数 1
回答已采纳
新的C# 8.0和dotnet core 3具有AsyncStreams (IAsyncEnumerable<T>)的这一新功能。我的理解是，它提供了一种异步处理流中的项的方法。但是我不能用IEnumerable<Task<T>>做到这一点吗？
这两种方法有什么不同？
浏览 32提问于2019-07-20得票数 11
2回答
更具体地说，如果用于初始化列表的IEnumerable在构造新列表的过程中被修改，那么List(T)(IEnumerable(T))是线程安全的吗？
浏览 0提问于2010-03-01得票数 3
回答已采纳
2回答
我不时地尝试折磨C#编译器。今天我想到了这个：
static void CallFirst<T>(T a) where T : IEnumerable<T>
{
a.First().ToString();
}
这是一个简单的错误，因为我想创建以集合作为参数的泛型方法，当然，这个方法应该如下所示：
static void CallFirst2<T>(IEnumerable<T> a)
{
a.First().ToString();
}
无论如何，甚至可以调用CallFirst()方法吗？每次传递集合时，都需要集合的集合。
如果不是，
浏览 1提问于2014-11-17得票数 5
回答已采纳
1回答
可以从多个线程安全地调用使用yield return返回IEnumerable的静态类中的静态函数吗？
public static IEnumerable<FooClass> FooClassObjects()
{
foreach (FooClassWrapper obj in listOfFooClassWrappers)
{
yield return obj.fooClassInst;
}
}
每个调用它的线程都会收到对集合中每个对象的引用吗？在我的情况下，listOfFooClassWrappers是在程序开始时写到的，所以我不需要担心
浏览 0提问于2015-12-14得票数 14
回答已采纳
1回答
流API周围的锁定和线程安全
、、、、
可能是一个相当简单的问题，但我想知道使代码线程安全的最佳实践。
我在mutli线程环境中使用外部的非线程安全API。
它返回一个IEnumerable<ApiDto>。然后，我将每个ApiDto映射到应用程序的DTO：MyDto。
如何确保代码是线程安全的？
例如：
这是我的类，它从API获取项。
public class ApiRepo
{
private IApi api;
public ApiRepo()
{
api=new Api("url");
}
public IEnumerable<MyDt
浏览 0提问于2018-07-05得票数 0
3回答
可能的重复：
是可以限制泛型类型参数的，我不知道这是否是一个Enum的正确名称
例如，我如何做这样的事情？
//VB.NET
Function GetValues(Of T As System.Enum)(ByVal value As T) As IEnumerable(Of T)
Return [Enum].GetValues(value.GetType)
End Function
//C#
public IEnumerable<T> GetValues<T>(T value) where T : System.Enum
{
return
浏览 6提问于2011-02-21得票数 28
回答已采纳
3回答
我的问题实际上是对的扩展，所以在返回属性之前测试属性的问题是空的。我也有类似的情况：
public class MyClass
{
private readonly string _Name { get; set; }
private readonly IEnumerable<T> _Values { get; set; }
private IEnumerable<T> _MyProp { get; private set; }
public IEnumerable<T
浏览 3提问于2015-12-16得票数 2
回答已采纳
由于我一直在整合Linq思想，我越来越倾向于通过IEnumerable<T>泛型类型传递集合，这似乎构成了大多数Linq操作的基础。
但是，我想知道，随着对IEnumerable<T>泛型类型的后期评估，这是否是一个好主意。使用T[]泛型类型更有意义吗？IList<T>？还是别的什么？
编辑：下面的评论非常有趣。但是，有一件事似乎还没有得到解决，那就是线程安全问题。例如，如果您将一个IEnumerable<T>参数带到一个方法中，并且它在一个不同的线程中被枚举，那么当该线程试图访问它时，其结果可能与传递的结果不同。更糟糕的是，尝试枚举IEnume
浏览 6提问于2008-12-28得票数 12
回答已采纳
1回答
我正在编写一个针对实体框架6.1.3的C# .NET4.5控制台应用程序。我采用的工作模式如下：
public class UnitOfWork : IUnitOfWork, IDisposable
{
private readonly DataContext _context;
private readonly List<object> _repositories = new List<object>();
public UnitOfWork(DataContext context)
{
_context = conte
浏览 4提问于2016-04-26得票数 4
回答已采纳
假设我有一个简单的方法：
public IEnumerable<uint> GetNumbers()
{
uint n = 0;
while(n < 100)
yield return n++;
}
你如何保证这个线程的安全？我的意思是，你只需要获取一次枚举数，然后让多个线程处理所有的数字，而不会有任何人得到重复的数字。
我认为需要在某个地方使用锁，但是锁必须在哪里才能使迭代器块成为线程安全的？一般来说，如果你想要一个线程安全的IEnumerable<T>，你需要记住什么？或者更确切地说，我猜它是一个线程安全的IEnumerator
浏览 0提问于2009-10-22得票数 43
回答已采纳
这应该是一个对所有的f#摇滚乐手，但这是一个快速的一个，但它使我在此刻被困。
我有一个F#类型，我正在尝试实现一个c#接口
public interface ICrudService<T> where T: DelEntity, new()
{
IEnumerable<T> GetAll();
}
下面是它在c#中的实现方式：
public IEnumerable<T> GetAll()
{
return repo.GetAll();
}
repo.GetAll返回一个IQueryable，但是c#编译器知道的足够多，可以转换为IEnumer
浏览 2提问于2014-05-31得票数 7
回答已采纳
6回答
在MSDN中，一些.NET类描述如下：
“这种类型是线程安全的.”
或
“公共静态(在Visual中共享)成员是线程安全的。实例成员不一定是线程安全的。”.。
我的问题是，哪些特性使类成为线程安全的？
是否有任何关于线程安全编程的标准、建议或指南？
当我使用锁(C#)关键字时，它意味着我的类是否线程安全？
如何评估类的线程安全性？是否有任何测试来确保一个类是100%线程安全的？
示例：
public class MyClass
{
public void Method()
{
lock (this)
{
浏览 12提问于2011-07-13得票数 26
回答已采纳
2回答
我正在尝试使用TreeNodes在代码中创建一个类似树的结构。我对TreeNodes一点也不熟悉。我之前做了一些搜索，但我仍然觉得我不是很清楚我在做什么。
我正在使用C#在Unity中创建一个游戏。我使用XML创建对话框，并希望将来自不同选项的不同选项存储在树状结构中。
它的可视化表示如下所示：
/--------|--------\ /--------|--------\
choice d choice e choice f choice g choice h choice i
诸若此类。
public c
浏览 0提问于2016-04-26得票数 3
3回答
我有一些用C#编写的代码。我正在尝试编写一些我可以重用的通用代码。我的实际代码更复杂。但是，代码的问题如下所示：
public async Task<T> ExecuteQueryAsync<T>(string sql)
{
var results = default(T);
using (var database = new SqlConnection("[ConnectionString]"))
{
database.Open();
results = await database.QueryAsync<T>(
浏览 1提问于2015-05-26得票数 3
回答已采纳
1回答
使用我认为是优秀文章中最好的内容，我成功地使用了以下类来将用户定义的数据持久化到内存中(对于很少修改的数据)：
public class Params
{
static readonly Params Instance = new Params();
Params()
{
}
public static Params InMemory
{
get
{
return Instance;
}
}
private IEnumerable<Localization> _localizations;
public
浏览 4提问于2012-01-11得票数 5
回答已采纳
6回答
来自以下网站：
不幸的是，List<>并不是线程安全的(C#的ArrayList和Vector是线程安全的)。C#还有一个Hashtable；通用版本是：
什么使List<T>不安全线程？这是.NET框架工程师部分的实现问题吗？还是泛型不是线程安全的？
浏览 14提问于2009-04-01得票数 44
回答已采纳
1回答
如何使C++动态链接库线程安全？
、、、、
我有合并图像的C++动态链接库，我正在从C#传递这个动态链接库的参数。
[DllImport("Image.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int ImageMerge(ref IntPtr ImagesData, ref IntPtr[] ImageParams, ref IntPtr ImageProgress);
这里，我需要让我的DLL线程安全，我不知道如何才能做到这一点。有没有有效的方法呢？
浏览 0提问于2021-05-24得票数 0
1回答
我一直在尝试如何在C# (命令是一个功能接口)中获得以下类似的Java代码。
public interface Executor<C extends Command> {
void execute(final C command) throws Exception;
}
按照我的代码目前在Java版本中的设计方式，C类型必须扩展命令，据我理解，在C#中使用协方差来处理命令。
然而，根据C#文档，像下面这样的东西无法工作，因为"“
interface IExecutor<out Command>
{
void Execute(Command com
浏览 0提问于2019-05-24得票数 0
回答已采纳
6回答
我有一个填充List<T>的主线程。此外，我创建了一个对象链，这些对象将在不同的线程上执行，需要访问列表。原始列表在生成后将永远不会被写入。我的想法是将列表作为IEnumerable<T>传递给在其他线程上执行的对象，主要是因为不允许那些实现这些对象的人错误地写入列表。换句话说，如果保证原始列表不会被写入，那么多线程在IEnumerable上使用.Where或foreach是否安全？
如果原始集合永远不变，我不确定迭代器本身是否是线程安全的。
浏览 1提问于2011-05-12得票数 15
回答已采纳
4回答
我有以下代码(用c#写的，但可以很容易地翻译成你喜欢的语言...)
class Program
{
static int sharedState = 0;
static void Main(string[] args)
{
Thread t1 = new Thread(UpdateState);
Thread t2 = new Thread(UpdateState);
t1.Start();
t2.Start();
t1.Join();
t2.Join();
浏览 0提问于2011-07-18得票数 1
我有这个C#代码，它可以工作，但不会等到方法完成
foreach (var listBoxItem in visualListBox1.Items)
{
lblCursor.Text = "Processing.. " + listBoxItem;
Thread t = new Thread(() => extract_group(listBoxItem.ToString()));
t.IsBackground = false;
t.Name = "Group Scrapper";
t.Start();
}
如何等
浏览 2提问于2018-05-19得票数 0
回答已采纳
根据我的理解，给定一个C#数组，同时从多个线程迭代数组的行为是--一种线程安全操作。
通过迭代数组，我意味着通过一个普通的for 循环读取数组中的所有位置。每个线程只是读取数组中一个内存位置的内容，没有人在写任何东西，所以所有线程都以一致的方式读取相同的内容。
这是一段代码，完成了我在上面写的代码：
public class UselessService
{
private static readonly string[] Names = new [] { "bob", "alice" };
public List<int> DoSo
浏览 0提问于2019-11-14得票数 8
回答已采纳
3回答
使自定义C#集合线程安全
、、、、
我创建了这个特定的集合类：
public class RangeObservableCollection<T> : ObservableCollection<T>
{
private bool _suppressNotification = false;
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
try
{
i
浏览 2提问于2015-04-02得票数 1
回答已采纳
2回答
在使用查询表达式时进行缓存？
、、、、
我读了一篇关于查询表达式如何延迟执行的文章。这是否意味着当我们有一个像这样的集合时：
IEnumerable<int> collection = from i in integers where i % 2 == 0 select i;
每次访问collection时都要重新计算吗？
如果是这样的话，处理这个问题的一般做法是什么？转换成一个新的集合？
另外，为什么C#设计者选择这种方式，而不是在第一次访问集合后将结果缓存到集合中？
另外，运行时如何知道collection是这样运行的(延迟执行)，这与我可能使用不延迟执行的List<T>创建的另一个IEnumerable
浏览 0提问于2009-07-08得票数 1
回答已采纳
1回答
我相信这个问题的答案很简单，但由于我已经在这个问题上花了一段时间的脑筋，所以我可能很难看清全局。
我希望加载多个文件(在本例中是JSON)，所以我创建了一个DataLoader类来处理这个问题。在这个类中，我创建了一个类将迭代和加载的ILoaders列表，这样在将来如果我使用JSON以外的东西，抽象就已经实现了。
public class DataLoader{
private List<IDataLoaded> allDataLoaded = new List<IDataLoaded>();
private List<ILoader>
浏览 2提问于2015-05-31得票数 1
回答已采纳
5回答
C#线程安全静态构件
、、、
我有一个带有静态成员的C#类，它是从多个线程读取并在一个线程中编写的。
据我所知，Uint64读写并不是所有系统上的原子操作，因此我必须手动确保线程安全。
我对如何做这件事有一些想法。
使用和原子包装类进行操作，如c++中的std::atomic类。在C#中有类似的实现吗？
在静态字段中使用易失性修饰符。然而，这是不允许的。为什么？
最后，我做了以下工作：
私有静态对象tick_time_lock；私有静态UInt64 _currentTickTime；公共静态UInt64 CurrentTickTime { get {返回_currentTickTime；} set { lock
浏览 3提问于2013-11-25得票数 5
回答已采纳
新的C#驱动程序完全是异步的，在我的理解中，它有点扭曲了旧的设计模式，比如n层架构中的DAL。
在我的Mongo DALs中，我经常这样做：
public T Insert(T entity){
_collection.Insert(entity);
return entity;
}
这样我就可以得到持久化的ObjectId。
今天，一切都是异步的，比如InsertOneAsync。
当entity完成时，Insert方法现在将如何返回InsertOneAsync？你能举个例子吗？
浏览 2提问于2015-05-07得票数 11
回答已采纳
我有一个想要传递给IEnumerable的Parallel.ForEach，但是IEnumerable是使用C#方法实现的，并且可能是枚举器中的代码不是线程安全的。计划在这个问题上使用Parallel.ForEach。我假设IEnumerable由ForEach进行的实际内部迭代总是在同一个线程上，然后ForEach将每个项传递给潜在的其他线程进行处理。这是正确的吗？
我看过IEnumerable迭代使用线程本地存储的地方，访问相同IEnumerable的不同线程都会有自己的迭代电流，next等等。这就是为什么我假设ForEach实际上将在同一个线程上执行所有迭代。
至少我知道迭代不是在调用P
浏览 6提问于2014-10-24得票数 6
1回答
我有三个问题：
你一般对我解决这个问题的方法有什么看法？
你认为我还能进一步提高性能吗？
最重要的一点是:如何使我的实现真正安全？
首先，我所处的简化场景是:我使用不同的设备通过消息传递系统进行通信。在相当短的时间内，我收到并发送了成千上万条信息。我在多线程环境中，所以很多不同的任务都在发送和期望消息。对于消息接收，事件驱动的方法在使线程安全方面给我们带来了很多麻烦。我有一些接收任务，这些任务从外部获取消息，并且必须将这些消息传递给许多使用者任务。
因此，我想出了一种不同的方法:为什么不拥有几千条消息的历史记录，其中每条新消息都被排队，使用者任务可以从最新的项向后搜索，以便
浏览 1提问于2016-03-06得票数 1
回答已采纳
如果我使用来自System.Collection.Concurrent命名空间(如ConcurrentDictionary<K, V> )的集合，其键和/或值类型不是线程安全，例如ConcurrentDictionary<int, Dictionary<int, int>> ，则可能面临哪些问题？
我假设我可以对ConcurrentDictionary本身做任何我喜欢的操作，但是如果我从这个ConcurrentDictionary创建一个Dictionary<int, int>的System.Collections.Generic.List<
浏览 5提问于2016-08-26得票数 1
回答已采纳
我经常用数据填充数据读取器，并像这样填充UI。
using (SqlConnection conn = new SqlConnection("myConnString"))
using (SqlCommand comm = new SqlCommand("Select * from employee where salary<5000", conn))
{
conn.Open();
SqlDataReader reader = comm.ExecuteReader();
if (reader.HasRows)
{
浏览 1提问于2012-08-14得票数 7
回答已采纳
下面的伪代码是线程安全的吗？
IList<T> dataList = SomeNhibernateRepository.GetData();
Parallel.For(..i..)
{
foreach(var item in dataList)
{
DoSomething(item);
}
}
列表永远不会改变，它只是并行地迭代和读取。不能写入字段或类似的东西。
谢谢。
浏览 0提问于2011-08-05得票数 37
回答已采纳
4回答
我从中了解到，C#静态字段初始化器“在第一次使用该类的静态字段之前执行”，但这仍然会产生我预期不到的结果，至少对于泛型类型是如此。
来自Java世界，我错过了我丰富的枚举，我用C#更严肃的泛型来思考，我应该能够用最少的样板复制它们。这里(去掉一些细节，比如可比性)是我想出来的：
public class AbstractEnum<T> where T : AbstractEnum<T>
{
static readonly IDictionary<String, T> nameRegistry = new Dictionary<String, T
浏览 3提问于2011-03-01得票数 2
回答已采纳
我查找并阅读了与我的问题类似的其他问题，我知道我尝试做的事情是不可能的，因为C#中的通用协方差限制。然而，我不太理解以下几点：
我有一个定义为
Problems<T> : IProblems<T> where T : IProblem
它有一个字段
protected List<T> problems = new List<T>();
现在我想做以下几件事：
protected virtual void OnNotifyRemainingProblems()
{
List<IProblem> remaining
浏览 0提问于2020-10-05得票数 0
一些程序员认为，最好是将IEnumerable<T>参数传递到传递实现(如List<T> )上，而这样做的一个流行原因是该API可以立即在更多的场景中使用，因为更多的集合将与IEnumerable<T>兼容，而不是任何其他特定的实现，例如List<T>。
我越深入到多线程开发场景中，我就越开始认为IEnumerable<T>也不是正确的类型，我将尝试解释下面的原因。
您是否在枚举集合时收到以下异常？
集合已被修改；枚举操作可能不会执行。( InvalidOperationException)
基本上，导致这种情况的原因是，您
浏览 21提问于2013-02-20得票数 9
回答已采纳
3回答
互斥作为类成员
、、、
class temp
{
boost::mutex mx;
void CriticalCode() {
boost::mutex::scoped_lock scoped_lock(mx);
//Do Something
return;
}
}
如果在堆(，temp* T = new temp())上分配了这个类，那么这个类是否是线程安全的(对于每个实例，不是所有实例一起)？如果我创建boost::mutex mx -> boost::mutex* mx，并在构造函数中分配它，以便在堆上分配它，那么代码是否也是
浏览 3提问于2011-05-10得票数 10
回答已采纳
4回答
public class TestClass
{
public TestClass(int id, string name)
{
Name = name;
Id = id;
}
public string Name
{ get; private set; }
public int Id
{ get; private set; }
public string Tag
{ get; set; }
public DateTime Time
{ get; set; }
}
浏览 0提问于2009-07-22得票数 4
回答已采纳
2回答
我正在寻找/tring来实现C#中的类型安全树实现。
如何实现类型安全树，而不使用接口(这迫使在各地重新实现树的功能)和不使用强制转换？
我有使用树作为公共基类的想法，但是类型安全性就消失了。我目前的方法是使用泛型。但我错过了一些转换回到基本类型。
下面是一个简化的/不工作的示例。其思想是返回的节点支持树函数，同时也支持它们的基本类型行为。我可以在不使用Node的情况下使用下面的类并从Node继承，但是这样一方面我就松了类型安全性，而且继承也会出现问题，因为节点已经有父类了。
我还玩过类扩展，但我没有任何可能的解决方案。
我想我需要一个关于如何继续下去的小提示。提前谢谢你。
public cl
浏览 0提问于2016-10-17得票数 1
回答已采纳
我对，Microsoft.Design "DoNotNestGenericTypesInMemberSignatures“有意见。具体来说，我正在设计一个继承自ReadOnlyCollection<Report<T>>的ReadOnlyCollection<Report<T>>类，它的public构造函数以一个IList<Report<T>>作为参数。
关于修正这一警告的建议并不十分有用：
“若要修复违反此规则的问题，请更改设计以删除嵌套类型参数。”到目前为止，我可以看到改变设计的两种方法：
使构造函数
浏览 8提问于2009-01-06得票数 25
回答已采纳
我想提出以下问题，这些问题以某种方式相互联系，并与下面的代码相关(简化-见评论)：
public class DataProcessor
{
private DataUpdater dataUpdater = new DataUpdater(someConnection);
public void Process()
{
Parallel.ForEach(itemCollection, (item, loopState) =>
{
ProcessItem(item);
// Q1.
浏览 5提问于2016-01-18得票数 1
回答已采纳
我有一个应用程序，它在C#中实现了几个对象，然后通过将这些对象添加到Microsoft.Scripting.Hosting.ScriptScope中，期望这些对象可以从IronRuby中使用。这在很大程度上是可行的:我已经学习了如何实现DynamicObject的各个成员以使事情正确运行。但是如何使对象与Ruby的for循环兼容呢？
我的C#对象如下所示：
public class TrialObject : DynamicObject, IEnumerable<int> {
public override bool TryGetIndex(GetIndexBinder
浏览 3提问于2014-06-29得票数 0
回答已采纳
2回答
我最近一直在使用C#，我注意到在我公司的代码中引发事件的大多数代码都是这样完成的：
EventHandler handler = Initialized;
if (handler != null)
{
handler(this, new EventArgs());
}
我真的不明白为什么，你不能这样做：
if (Initialized != null)
{
Initialized(this, new EventArgs());
}
编辑：
一些值得深思的东西，我试着做了一些测试：
using System;
using System.Collections.Generic;
浏览 0提问于2012-02-17得票数 8
回答已采纳
在C#中，考虑到：
IEnumerable<T>声明Where(Func<T, bool>)
IQueryable<T>扩展IEnumerable<T>
IQueryable<T>声明Where(Expression<Func<T, bool>>))
使用时：
var list = new List<int>();
var positives = list.AsQueryable().Where(x => x > 0);
C#编译器如何区分这两种方法？
浏览 2提问于2019-09-19得票数 1
回答已采纳
4回答
假设有几个这样的类型：
interface I {}
class C : I {}
如何进行静态类型转换？我的意思是:我怎样才能以一种在编译时被检查的方式改变它的类型？
在C++中，您可以执行static_cast<I*>(c)。在C#中，我能做的最好的事情就是创建一个备用类型的临时变量，并尝试将其赋值：
var c = new C();
I i = c; // statically checked
但这会阻止流利的编程。我必须创建一个新的变量来进行类型检查。所以我决定这样做：
class C : I
{
public I I { get { return this; }
浏览 1提问于2010-10-09得票数 3
回答已采纳
2回答
我正要构建自己的IEnumerable类，它在第一次迭代时对所有项执行一些操作，然后我开始想，这个框架是否已经有一些我可以使用的东西？
这是我正在构建的，这样你就知道我在寻找什么了：
public class DelayedExecutionIEnumerable<T> : IEnumerable<T>
{
IEnumerable<T> Items;
Action<T> Action;
bool ActionPerformed;
public DelayedExecutionIEnumerable(IEnumer
浏览 0提问于2011-03-31得票数 0
回答已采纳
5回答
C#数组，如何使数组中的数据彼此不同？例如
string[] a = {"a","b","a","c","b","b","c","a"};
如何获取
string[]b = {"a","b","c"}
浏览 0提问于2010-11-12得票数 10
回答已采纳
2回答
我不喜欢这段代码，但我总是对线程感到困惑，所以在我建议更改之前，我想要别人的输入；这是线程安全的吗(尽管是基于C#的伪代码)：
class ThreadCreator
{
private AnObject obj = new AnObject();
public ThreadCreator()
{
for (int i = 0; i < 100; ++i)
{
ThingToThread th = new ThingToThread();//don't care about losing ref to
浏览 2提问于2011-12-01得票数 1
回答已采纳
如何在给定内部字段数据、大小和容量的情况下实现std：：向量的移动示意图？我如何使这个线程安全？
#include <utility>
class vec {
public:
vec(vec&& o) : size(o.size), capacity(o.capacity), data(std::move(o.data))
{}
vec& operator=(vec&& o)
{
if (this != &o) {
size = o.size;
浏览 2提问于2016-06-22得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
