小编Pol*_*ity的帖子

我一直在阅读新的并发集合,特别是ConcurrentBag引起了我的注意.由于ConcurrentBag在每个单独的线程上内部拥有一个本地集来使用它来跟踪项目,这意味着当线程本身超出范围时,ConcurrentBag仍将在内存中引用它.这反过来意味着线程声称的内存,以及本机资源？(请原谅我不知道.NET线程对象的确切内部工作原理)

我可以假设一个用例,你有一个全局ConcurrentBack用于多线程webservice,你有很多客户端添加任务.这些任务由线程池上的线程添加.现在,线程池是一种非常有效的管理线程的方法,但它确实根据工作量删除并创建了线程.因此,这样的web服务有时会发现自己遇到麻烦,因为底层包仍在引用许多应该被破坏的线程.

我创建了一个快速应用程序来测试此行为:

    static ConcurrentBag<int> bag = new ConcurrentBag<int>();
    static void FillBag() { for (int i = 0; i < 100; i++) { bag.Add(i); } }
    static void PrintState() { Console.WriteLine("Bag size is: {0}", bag.Count); }
    static void Main(string[] args)
    {
        var remote = new Thread(x =>
        {
            FillBag();
            PrintState();
        });
        // empty bag
        PrintState();
        // first 100 items are added on main thread
        FillBag();
        PrintState();
        // second 100 items are added on remote thread
        remote.Start();
        remote.Join();
        // since the …

假设我有一个处理器,他的工作就是将文件保存回磁盘.这是Task在观察BlockingCollection<T>要处理的文件的同时运行.

当任务被取消并且仍然存在应该保存到磁盘的文件时,这样做的好习惯是什么？

尽管我不确定这是否与取消任务的理念相冲突(因为取消应该尽可能快地发生),但是在退出之前让任务正确并将剩余的文件快速写回磁盘是很方便的.

另一个选择是在取消任务之后执行第二个过程,其任务是将剩余文件写入磁盘.

代码示例:

class FileProcessor
{
    private readonly BlockingCollection<Stream> input;

    public FileProcessor(BlockingCollection<Stream> input)
    {
        _input = input;
    }

    public Task Run(CancellationToken cancellationToken, 
        BlockingCollection<Stream> input)
    {
        return Task.Factory.StartNew(() => 
        {
            foreach (Stream stream in 
                        input.GetConsumingEnumerable(cancellationToken))
            {
                WriteToDisk(stream);
            }

            // Should I call WriteRemaining here or should I have
                    // a process running after this task exited which 
                    // will call WriteRemaining
            WriteRemaining();
        });
    }

    public void WriteRemaining()
    {
        foreach (Stream stream in input)    
        {
            WriteToDisk(stream); …

如果你看一下:http://jsfiddle.net/KA4dz/

在此演示中,您可以清楚地看到内部元素由于其旋转而到达外部元素的外部.要求是缩小内部元素(同时保持纵横比和中心定位),使其适合其容器.

用例是用户可以手动旋转这样的内部元件,同时确保它保持在外部元件内.(所以简单地缩小直到它适合眼睛不是一个解决方案).

这是一个我的数学技能显然缺乏的场景.发布我试过的东西在这个阶段不会做得很好.有人能指出我正确的方向吗？

谢谢!

另外一个要求是内部元素只在需要时缩小,但在不需要时则不缩小(必要时意味着离开外部元素的边界)

要保存点击:

.outer{
    border: 1px solid black;
    width: 100px;
    height: 50px;
    margin: 100px;
}

.inner{
    background: blue;
    width: 100px;
    height: 50px;

    transform: rotate(-40deg);
    -webkit-transform: rotate(-40deg);
}

<div class="outer">
    <div class="inner">
    </div>
</div>        

令我恼火的一件事是,在默认事件中,Sender属于object类型,因此在我们使用它之前几乎总是需要手动转换.幸运的是,由于VB现在也支持委托中的差异,我们可以以强类型发送者的方式更新事件的签名,请参阅:事件参数; "发件人为对象",或"发件人为T"？

遗憾的是,这对于发送者属于object类型的现有声明事件不起作用.

现在一个解决方案就是生成一个假的EventHandler,它在内部为你处理演员表.我做了一个简单的例子,见:

struct EventHandler<TSender, TEventArgs>
    where TEventArgs: EventArgs
{
    private readonly Action<TSender, TEventArgs> _delegate;

    public EventHandler(Action<TSender, TEventArgs> @delegate)
    {
        if (@delegate == null)
            throw new ArgumentNullException("@delegate");

        _delegate = @delegate;
    }

    public static implicit operator EventHandler<TEventArgs>(EventHandler<TSender, TEventArgs> eventHandler)
    {
        return new EventHandler<TEventArgs>(eventHandler.Execute);
    }

    private void Execute(object sender, EventArgs e)
    {
        TSender typedSender = (TSender)sender;
        TEventArgs typedEventArgs = (TEventArgs)e;

        _delegate(typedSender, typedEventArgs);
    }
}

可以按照您的预期使用它:

class Program
{
    event EventHandler<EventArgs> Test;

    static void Main(string[] args)
    {
        new Program().Main();
    }

    void …

不幸的是,我找不到导致我这个问题的原始项目.这可能会给这个问题带来更多背景.

编辑:我发现原始项目我已经看到了这个:http://mews.codeplex.com/SourceControl/changeset/view/63120#1054567,具体实现在:http://mews.codeplex.com/SourceControl /变更/视图/ 63120#1054606

让我们说我有一个抽象类,具体实现了一些有用的东西:

abstract class AbstractClass
{
    public virtual int ConvertNumber(string number)
    {
        string preparedNumber = Prepare(number);
        int result = StringToInt32(number);
        return result;
    }

    protected abstract string Prepare(string number);

    protected virtual int StringToInt32(string number)
    {
        return Convert.ToInt32(number);
    }
}

sealed class ConcreteClass : AbstractClass
{
    protected override string Prepare(string number)
    {
        return number.Trim();
    }

    public override int ConvertNumber(string number)
    {
        return base.ConvertNumber(number);
    }
}

这是基本的.现在在我在网上看到的代码中,作者通过从最派生类型继承Abstract类来实现继承,例如:

abstract class AbstractGenericClass<TGenericClass>
    where TGenericClass …

我正在通过移植一些旧的套接字代码以使用TPL数据流和新的异步功能来尝试TPL数据流。尽管API感觉很坚如磐石，但我的代码仍然最终变得混乱。我想知道我是否在这里错过了什么。

我的要求如下：一个套接字类公开：Open，Close，Send和Receive方法。全部都返回一个Task，因此是异步的。打开和关闭是原子的。尽管发送和接收一次只能处理1条命令，但它们可以彼此相邻工作。

从逻辑上讲，这使我进入下一个内部控制代码：

// exposing an exclusive scheduler for connectivity related tasks and a parallel scheduler where send and receive can work with
private readonly ConcurrentExclusiveSchedulerPair exclusiveConnectionSchedulerPair;
private readonly ActionBlock<Action> connectionBlock;
private readonly ActionBlock<Action> sendBlock;
private readonly ActionBlock<Action> receiveBlock;

// within the constructor:
this.exclusiveConnectionSchedulerPair = new ConcurrentExclusiveSchedulerPair();
this.connectionBlock = new ActionBlock<Action>(action => action(), new ExecutionDataflowBlockOptions()  { TaskScheduler = exclusiveConnectionSchedulerPair.ExclusiveScheduler });
this.sendBlock = new ActionBlock<Action>(action => action(), new ExecutionDataflowBlockOptions()    { TaskScheduler = exclusiveConnectionSchedulerPair.ConcurrentScheduler });
this.receiveBlock = new ActionBlock<Action>(action => action(), new …