小编Bry*_*sby的帖子

尝试使用"Head First Design Patterns"一书(用Java编写)中的代码在C#中实现装饰器模式.

我刚刚开始使用C#,因此我仍然对语法不熟悉,所以我不确定为什么我不能让下面的注释代码行工作.

这是Decorator模式中的第一个抽象基类及其派生类:

using System;

public abstract class Beverage
{
    private String m_description;

    // get a description of the beverage
    public virtual String Description { get { return m_description; } }

    // calculate cost of the beverage
    public abstract double Cost();
}

// HouseBlend coffee implements Beverage
public class HouseBlend : Beverage
{
    // Constructor
    public HouseBlend() { m_description = "House Blend"; }

    // calculate base cost of House Blend
    public override double Cost() { return 0.89; …

我有一个任务,启动几个子任务.(例如,任务A创建B,C,D,E,F).我还创建了System.Threading.Timer一个每10秒轮询一次数据库的程序,以检查计划项是否被请求取消.如果是,则设置CancellationTokenSource为任务知道取消.每个子任务(在本例中为B,C,D,E,F)将在适当时取消(它们通过文件循环并移动它们).

自从Task实现以来IDisposable,我想知道Task.WaitAll从catch块中再次调用是否是一个好主意,等待取消传播.在处理取消请求时,子任务可能处于循环的中间,并且在完成之前不能取消

但是,根据MSDN:

在释放对任务的最后一个引用之前,请始终调用Dispose.否则,在垃圾收集器调用Task对象的Finalize方法之前,不会释放它正在使用的资源.

我应该在我的任务数组上再次调用wait来正确调用数组中的Dispose()每个任务吗？

public class MyCancelObject
{
  CancellationTokenSource Source { get;set;}
  int DatabaseId { get;set;}   
}

private void CheckTaskCancelled(object state)
{
  MyCancelObject sourceToken = (MyCancelObject)state;

  if (!sourceToken.CancelToken.IsCancellationRequested)
  {
    //Check database to see if cancelled -- if so, set to cancelled
    sourceToken.CancelToken.Cancel();
  }
}

private void SomeFunc()
{
  Task.StartNew( () =>
  {
    MyCancelObject myCancelObject = new MyCancelObject(
      databaseId,
      new CancellationTokenSource());
    System.Threading.Timer cancelTimer = new Timer( …

      var servers = new List<IChecker> {
      //Server1
      new DatabaseSystem { ServerName = "ANTIVIRUS" },
      new DatabaseSizes  { ServerName = "ANTIVIRUS"},
      new DiskBackup { ServerName = "ANTIVIRUS"},
      new SqlServerEventLog { ServerName="ANTIVIRUS"},
      new DiskSystem { ServerName="ANTIVIRUS"}, 
      //Server1
      new DatabaseSystem { ServerName="SEJKG-S-DB01" },
      new DatabaseSizes  { ServerName = "SEJKG-S-DB01"},
      new DiskBackup { ServerName = "SEJKG-S-DB01"},
      new SqlServerEventLog { ServerName="SEJKG-S-DB01"},
      new DiskSystem { ServerName="SEJKG-S-DB01"},
  };

  var builder = new ContainerBuilder();            
  builder.RegisterInstance(notifiers).As<IList<INotifier>>();     
  builder.RegisterInstance(servers).As<IList<IChecker>>();
  builder.Register(c => new ServerChecker(c.Resolve<IList<IChecker>>(),  c.Resolve<IList<INotifier>>()));
  return builder.Build();

我有一个问题,我应该如何向Container Builder注册我的"where server = new …

我有一个设计问题.我想要一些反馈来了解ThreadPool是否适合我正在编写的客户端程序.

我有一个客户端作为服务处理数据库记录运行.这些记录中的每一个都包含外部FTP站点的连接信息[基本上它是要传输的文件队列].他们中的很多人都是同一个主机,只是移动不同的文件.因此,我正在由主持人将它们组合在一起.我希望能够为每个主机创建一个新线程.我真的不在乎转移完成时,他们只需要完成所有工作(或尝试做)他们被分配,然后在完成后终止,清理他们在过程中使用的所有资源.

我预计不会建立超过10-25个连接.传输队列为空后,程序将等待,直到队列中再次出现记录.

ThreadPool是一个很好的候选者,还是应该采用不同的方法？

编辑:在大多数情况下,这是服务器上运行的唯一重要的自定义应用程序.

我有一个我已经构建的页面,它动态生成用户控件.例如,用户控件有两个可以编辑的字段:SomeId和SomeData.我希望能够基于a设置这些值UserControlObject.当我之后读取控件时,我希望能够UserControlObject从控件返回一个并将数据库值设置为该值.我在使值保持最新状态时遇到一些麻烦.

//Page
public class SomePage
{
    private List<MyUserControl> _MyUserControls;

    private void InitControls()
    {
      var controlsToBuild = SomeDatabaseCallToGetControlObjects();

          foreach(MyUserControl control in controlsToBuild)
          {
        MyUserControl control = this.Page.LoadControl("MyControl.ascx") as MyUserControl;

          UserControlPlaceHolder.Controls.Add(myControl);
          _MyUserControls.Add(myControl);
      }
    }

    protected void Page_Init(object sender, EventArgs e)
    {
       InitControls();
    }

    protected void SaveButton_Click(object sender, EventArgs e)
    {
      if (this.IsValid)
      {
        List<MyUserObject>listObj = new List<MyUserObject>();
        foreach(MyUserControl control in _MyUserControls)
        {
           MyUserObject obj = control.GetObjectFromControl();
           listObjs.Add(obj);
        }
        SaveToDatabase(listObjs);
        //Clear placeholder in case number of controls has changed …

我的任务看起来像这样:

var task = Task.Factory.StartNew <object>(LongMethod);
task.ContinueWith(TaskCallback, TaskScheduler.FromCurrentSynchronizationContext());

LongMethod调用一个长期运行的服务,在此期间我不能(或者至少不认为我可以),不断轮询取消令牌以查看它是否已被取消.但是,我有兴趣'取消'或忽略回调方法.

当调用TaskCallback时,我只对'结果'感兴趣,如果它来自最近的任务(让我们假设LongMethod调用的服务保留了顺序,并且还假设用户可以多次单击该按钮,但只有最新的一个是相关的).

我已经通过以下方式修改了我的代码:创建任务后,我将其添加到堆栈的顶部.在TaskCallback中,我检查传递给回调的任务是否是最新的任务(即堆栈顶部的TryPeek).如果不是,我只是忽略了结果.

private ConcurrentStack<Task> _stack = new ConcurrentStack<Task>();

private void OnClick(object sender, ItemClickEventArgs e)
{
    var task = Task.Factory.StartNew < object >( LongMethod);
    task.ContinueWith(TaskCallback, TaskScheduler.FromCurrentSynchronizationContext());
    _stack.Push(task);
 }


private void TaskCallback(Task<object> task)
{
    Task topOfStack;
    if(_stack.TryPeek(out topOfStack)) //not the most recent
    {
        if (task != topOfStack) return;
    }
    //else update UI
}

我很确定这不是"最佳实践"解决方案.但是什么呢？传递和维护取消令牌也不是那么优雅.

我有一个遗留系统,使用表格来排序数字.该表具有以下定义:

dbo.id_table
(
    table_name char(64) NOT NULL,
    id_type char(5) NOT NULL,
    data_type char(5) NOT NULL,
    next_id_number int NOT NULL,
    next_id_max char(15) NOT NULL
)
PRIMARY KEY CLUSTERED 
(
    table_name ASC
) WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

此表在功能上等同于标识列.

以下是表的使用方法: - 运行存储过程以获取表中id的下一个值.例如,

exec id_proc 'bryans_table', @some_int_value output

我正在寻找专家来回答以下问题:

对于使用SQL Server 2008 R2这样的设计(当前在兼容模式下运行,但计划在将来的某个时间点使用完整的2008 R2)与使用常规标识列相比,性能影响(尽可能具体) ？这种规模是否完全？

我们看到这个表存在很多争议,我想知道表是否切换到标识列可能会有哪些性能增益(或丢失)？在这一点上,争论的来源尚不清楚.

(我不知道为什么标识列没有包含在原始设计中 - 这是一个遗留数据库)

我有一个处理文件传输的应用程序.在某些情况下,我需要启动一些处理文件的前/后处理可执行文件.

所以事件的顺序(简而言之)就像这样:

1. 工作线程已创建
2. 工作人员意识到需要在开始传输之前启动预处理可执行文件预处理启动,工作人员等待......如果等待时间过长,则不会发生传输,线程应该优雅地完成
3. 文件已转移
4. 工作人员意识到在传输完成后需要启动后处理可执行文件
5. 后期处理启动,工人不在乎等待

基本上,我不关心在传输发生后后进程可执行文件运行多长时间.因此,如果我从一个然后返回池中的线程启动进程,我是否应该预料到任何问题？

//后期过程

        Process process = null;
        ProcessStartInfo psi = new ProcessStartInfo(executable, args);
        psi.UseShellExecute = true;

        try
        {
            process = Process.Start(psi);
            //The pre-process simply calls Process.WaitForExit(timeout value)
            launched = true;
        }
        catch (InvalidOperationException) { }
        catch (ArgumentException) { }
        catch (System.ComponentModel.Win32Exception) { }
        catch (System.IO.FileNotFoundException) { }