Question

我正在使用Impersonator类（请参阅http://www.codeproject.com/KB/cs/zetaimpersonator.aspx）在运行时切换用户上下文。

与此同时，我现在正在将我的程序从单线程设计重构为多线程设计（使用TPL /主要是Task类型）。

由于这种模拟是在线程级别上使用本机API函数发生的事情，我想知道TPL与它兼容的程度。如果我更改了任务中的用户上下文，那么如果任务完成并且线程返回到ThreadPool，那么该用户上下文是否仍然设置？在此任务中启动的其他任务是否会隐式使用该上下文？

我试图自己找出单元测试，以及我从第一次单元测试中得到的推论：

任务在线程内部开始，同时模仿＆＃34;神奇地＆＃34;继承用户上下文。
当原始任务/线程执行Impersonation.Undo（）时，不会撤消继承的模拟。

第二个单元测试表明，如果没有明确撤销模拟，则用户上下文＆＃34;幸存下来＆＃34;在返回线程池的线程上，以及其他后续任务现在可以在不同的用户上下文中随机运行，具体取决于它们被分配给的线程。

我的问题：有没有比通过本机API调用更好的方式来实现模拟？也许一个更专注于TPL并绑定到任务而不是线程？如果有一个变化来减轻在随机环境中执行任务的风险，我很乐意这样做......

这是我写的2个单元测试。如果您想自己运行测试，则必须稍微修改代码以使用您自己的机制来接收用户凭据，并且肯定可以轻松删除log4net调用。

是的，我知道，Thread.Sleep（）是不好的风格，我在那里懒惰...... ... - ）

  private string RetrieveIdentityUser()
  {
     var windowsIdentity = WindowsIdentity.GetCurrent();
     if (windowsIdentity != null)
     {
        return windowsIdentity.Name;
     }
     return null;
  }

  [TestMethod]
  [TestCategory("LocalTest")]
  public void ThreadIdentityInheritanceTest()
  {
     string user;
     string pw;
     Security.Decode(CredentialsIdentifier, out user, out pw);

     string userInMainThread = RetrieveIdentityUser();
     string userInTask1BeforeImpersonation = null;
     string userInTask1AfterImpersonation = null;
     string userInTask2 = null;
     string userInTask3 = null;
     string userInTask2AfterImpersonationUndo = null;

     var threadlock = new object();
     lock (threadlock)
     {
        new Task(
           () =>
           {
              userInTask1BeforeImpersonation = RetrieveIdentityUser();
              using (new Impersonator(user, Domain, pw))
              {
                 userInTask1AfterImpersonation = RetrieveIdentityUser();
                 lock (threadlock)
                 {
                    Monitor.Pulse(threadlock);
                 }
                 new Task(() =>
                 {
                    userInTask2 = RetrieveIdentityUser();
                    Thread.Sleep(200);
                    userInTask2AfterImpersonationUndo = RetrieveIdentityUser();
                 }).Start();
                 Thread.Sleep(100);
              }
           }).Start();

        Monitor.Wait(threadlock);
        RetrieveIdentityUser();
        new Task(() => { userInTask3 = RetrieveIdentityUser(); }).Start();
        Thread.Sleep(300);

        Assert.IsNotNull(userInMainThread);
        Assert.IsNotNull(userInTask1BeforeImpersonation);
        Assert.IsNotNull(userInTask1AfterImpersonation);
        Assert.IsNotNull(userInTask2);
        Assert.IsNotNull(userInTask3);

        // context in both threads equal before impersonation
        Assert.AreEqual(userInMainThread, userInTask1BeforeImpersonation);

        // context has changed in task1
        Assert.AreNotEqual(userInTask1BeforeImpersonation, userInTask1AfterImpersonation);

        // impersonation to the expected user
        Assert.AreEqual(Domain + "\\" + user, userInTask1AfterImpersonation);

        // impersonation is inherited
        Assert.AreEqual(userInTask1AfterImpersonation, userInTask2);

        // a newly started task from the main thread still shows original user context
        Assert.AreEqual(userInMainThread, userInTask3);

        // inherited impersonation is not revoked
        Assert.AreEqual(userInTask2, userInTask2AfterImpersonationUndo);
     }
  }

  [TestMethod]
  [TestCategory("LocalTest")]
  public void TaskImpersonationTest()
  {
     int tasksToRun = 100; // must be more than the minimum thread count in ThreadPool
     string userInMainThread = RetrieveIdentityUser();
     var countdownEvent = new CountdownEvent(tasksToRun);
     var exceptions = new List<Exception>();
     object threadLock = new object();
     string user;
     string pw;
     Security.Decode(CredentialsIdentifier, out user, out pw);
     for (int i = 0; i < tasksToRun; i++)
     {
        new Task(() =>
        {
           try
           {
              try
              {
                 Logger.DebugFormat("Executing task {0} on thread {1}...", Task.CurrentId, Thread.CurrentThread.GetHashCode());
                 Assert.AreEqual(userInMainThread, RetrieveIdentityUser());
                 //explicitly not disposing impersonator / reverting impersonation
                 //to see if a thread reused by TPL has its user context reset
                 // ReSharper disable once UnusedVariable
                 var impersonator = new Impersonator(user, Domain, pw);
                 Assert.AreEqual(Domain + "\\" + user, RetrieveIdentityUser());
              }
              catch (Exception e)
              {
                 lock (threadLock)
                 {
                    var newException = new Exception(string.Format("Task {0} on Thread {1}: {2}", Task.CurrentId, Thread.CurrentThread.GetHashCode(), e.Message));
                    exceptions.Add(newException);
                    Logger.Error(newException);
                 }
              }
           }
           finally
           {
              countdownEvent.Signal();
           }
        }).Start();
     }
     if (!countdownEvent.Wait(TimeSpan.FromSeconds(5)))
     {
        throw new TimeoutException();
     }
     Assert.IsTrue(exceptions.Any());
     Assert.AreEqual(typeof(AssertFailedException), exceptions.First().InnerException.GetType());
  }

}

Answer 1

WindowsIdentity（通过模拟更改）存储在SecurityContext中。您可以确定这种假冒行为＆＃34;如何流动＆＃34;在various ways。既然你提到过，你正在使用p / invoke，请注意SecurityContext documentation：

中的警告

公共语言运行库（CLR）知道模拟操作仅使用托管代码执行，而不是执行模拟托管代码之外，例如通过平台调用...

但是，我并不完全确定模仿是真的从一个任务继承到另一个任务，或者您观察的行为是否是由于任务内联。在某些情况下，新任务可能在同一个线程池线程上同步执行。您可以找到关于此here的精彩讨论。

尽管如此，如果您想确保某些任务始终在模拟下运行，而其他任务不在，我可以建议您查看自定义任务计划程序。 how to write your own上有关于MSDN的文档，包括code-samples for a few common types of schedulers，您可以将其作为起点。

由于模拟是一个每线程设置，因此您可以拥有自己的任务调度程序，以便在执行任务时保留在模拟下运行的一个线程（或几个线程）。当你有许多小工作单元时，这也可以减少你进出模拟的次数。

TPL和假冒

1 个答案: