Asp.net 多用户EWS通知中心

我正在尝试创建一个服务，将exchange通知推送到asp.net应用程序，最终使用SignalR

我的计划是创建一个通知中心，在每个用户登录到asp应用程序时为其订阅通知，并侦听通知。收到通知后，项目的第二部分将使用signalR仅向每个用户发送正确的通知。一旦他们注销或超时，通知中心将取消他们的订阅

到目前为止，我已经做了一些基本的测试，可以在一个小控制台应用程序中接收通知，并对我的凭证进行硬编码。我正在努力解决的是如何同时为多个人做这件事。例如，我必须为每个用户创建单独的线程，还是有更好的方法

我想不管怎样，我将不得不使用模拟，而不是持有每个用户的凭据，对吗？如果每个用户都有一个活动会话，我还必须找到一种自动刷新超时的方法

下面是我发现并一直在使用的一段代码，如果有人能分享我如何最好地实现这一点的想法或示例，我将不胜感激

非常感谢

安迪

---

我解决这个问题的方法是：

拥有有权模拟所有用户的帐户

我通过提供用户名和密码为该帐户创建服务 密码

我模拟用户并将该用户的订阅添加到 联系

我创建了另一个服务，它是主服务的结束 相同的用户名和密码，将模拟其他用户 然后在之前将订阅添加到同一连接

下面是我的代码的两部分。忘了LogDevice吧，它只是内部的东西。 第一部分是详细的模拟，并将服务添加到服务列表中 在我的例子中，服务列表是一个字典，其中userSMTP是密钥，这里的userSMTP密钥是模拟帐户

    /// <summary>
    /// Impersonate one user at a time and without using the autodiscovery method to find the proper url for the userSmtp, 
    /// and copy the provided url to the usersmtp.
    /// </summary>
    /// <param name="url"> </param>
    /// <param name="userSmtp">user smtp</param>
    /// <param name="enableTrace">to enable logging from the XML tracing </param>
    /// <param name="exchangeVersion">Exchange server version used</param>
    private Uri ImpersonateUser(Uri url, string userSmtp, bool enableTrace, ExchangeVersion exchangeVersion)
    {
        Uri result = url;
        var log = "ImpersonateUser \n";
        try
        {
            log += "0/8 Checking services redundancy\n";
            if (Services.ContainsKey(userSmtp))
            {
                Services.Remove(userSmtp);
            }
            log += "1/8 Create a new service for " + userSmtp + "\n";
            var service = new ExchangeService(exchangeVersion);

            log += "2/8 Get credentials for the service\n";
            var serviceCred = ((System.Net.NetworkCredential)(((WebCredentials)(Services.First().Value.Credentials)).Credentials));

            log += "3/8 Assign credentials to the new service\n";
            service.Credentials = new WebCredentials(serviceCred.UserName, serviceCred.Password);

            log += "4/8 TraceEnabled is" + enableTrace.ToString() + "\n";
            service.TraceEnabled = enableTrace;

            log += "5/8 Get the Url for the  service with AutodiscoverUrl \n";
            service.Url = url;

            log += "6/8 Assign a new ImpersonatedUserId to the new service for" + userSmtp + "\n";
            service.ImpersonatedUserId = new ImpersonatedUserId(ConnectingIdType.SmtpAddress, userSmtp);

            try
            {
                log += "7/8 Validating the impersonation\n";
                RuleCollection rulecoll = service.GetInboxRules();
            }
            catch (Exception ex)
            {
                _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUser: failed to validate the impersonation for {0}\n Exception: {1}\n", userSmtp, ex.Message);
                int hr = System.Runtime.InteropServices.Marshal.GetHRForException(ex);

                if (hr == -2146233088) // We do not have right to impersonate this user.
                {
                    result = null;
                    return result;
                }
                else
                {
                    _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUser(2): trying to resolve {0} with Autodiscover instead...", userSmtp);
                    result = ImpersonateUser(userSmtp, enableTrace, exchangeVersion);
                }

            }

            log += "8/8 Adding the service \n";
            if (!Services.ContainsKey(userSmtp))
            {
                Services.Add(userSmtp, service);
                _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUser(2): {0} has been impersonated\n", service.ImpersonatedUserId.Id);
            }
        }
        catch (Exception ex)
        {
            _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUser(2): exception {0}\n The exception occured after the following steps: \n{1}", ex.Message, log);
        }
        return result;
    }

//
///一次模拟一个用户，而不使用自动发现方法查找用户SMTP的正确url，
///并将提供的url复制到usersmtp。
/// 
///  
///用户smtp
///从XML跟踪启用日志记录
///使用的Exchange服务器版本
私有Uri模拟用户（Uri url、字符串userSmtp、bool enableTrace、ExchangeVersion ExchangeVersion）
{
Uri结果=url；
var log=“模拟用户\n”；
尝试
{
日志+=“0/8检查服务冗余\n”；
if（Services.ContainsKey（userSmtp））
{
删除（userSmtp）；
}
日志+=“1/8为”+userSmtp+“\n”创建新服务；
var服务=新的ExchangeService（exchangeVersion）；
log+=“2/8获取服务的凭据\n”；
var serviceCred=（（System.Net.networkcredentials）（（WebCredentials）（Services.First（）.Value.Credentials））.Credentials））；
log+=“3/8为新服务分配凭据\n”；
service.Credentials=新的WebCredentials（serviceCred.UserName、serviceCred.Password）；
log+=“4/8 TraceEnabled是”+enableTrace.ToString（）+“\n”；
service.TraceEnabled=启用跟踪；
log+=“5/8使用AutoDiscoveryURL获取服务的Url\n”；
Url=Url；
log+=“6/8为“+userSmtp+”\n”的新服务分配一个新的模拟用户ID；
service.ImpersonatedUserId=新的ImpersonatedUserId（ConnectingIdType.SmtpAddress，userSmtp）；
尝试
{
日志+=“7/8验证模拟\n”；
RuleCollection rulecoll=service.GetInboxRules（）；
}
捕获（例外情况除外）
{
_logDevice.LogSrvMessage（1，“ExchangeLiteService:ImpersonateUser:无法验证{0}\n异常：{1}\n”，userSmtp，ex.Message）的模拟；
int hr=System.Runtime.InteropServices.Marshal.GetHRForException（ex）；
if（hr==-2146233088）//我们无权模拟此用户。
{
结果=空；
返回结果；
}
其他的
{
_logDevice.LogSrvMessage（1，“ExchangeLiteService:ImpersonateUser（2）：尝试使用自动发现来解析{0}”，userSmtp）；
结果=模拟用户（userSmtp、enableTrace、exchangeVersion）；
}
}
日志+=“8/8添加服务\n”；
如果（！Services.ContainsKey（userSmtp））
{
添加（userSmtp，服务）；
_logDevice.LogSrvMessage（1，“ExchangeLiteService:ImpersonateUser（2）：{0}已被模拟，\n”，service.ImpersonatedUserId.Id）；
}
}
捕获（例外情况除外）
{
_logDevice.LogSrvMessage（1，“ExchangeLiteService:ImpersonateUser（2）：异常{0}\n异常发生在以下步骤之后：\n{1}”，例如消息，日志）；
}
返回结果；
}

下面是调用上一个函数（即所有用户）的代码，记住您应该以某种方式存储每个要模拟的帐户的电子邮件地址

/// <summary>
        /// To Impersonate users in order to get the info from them. 
        /// </summary>
        /// <param name="userSmtps">List of users to be impersonated</param>
        /// <param name="enableTrace"> To enable logging from the XML tracing</param>
        /// <param name="exchangeVersion">Exchange server version used </param>
        public void ImpersonateUsers(ICollection<string> userSmtps)
        {
            var log = "ImpersonateUsers\n";
            var firstUserSmtp = "";
            if (userSmtps != null)

                if (userSmtps.Count > 0)
                {

                    //the url for the first smtp
                    try
                    {
                        log += "1/2 Impersonating the first userSmtp\n";
                        _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUsers:  Getting the Url from the autodiscovery for the first smtp {0} ", userSmtps.First());
                        bool enableTrace = Services.First().Value.TraceEnabled;

                        ExchangeVersion exchangeVersion = Services.First().Value.RequestedServerVersion;
                        firstUserSmtp = userSmtps.First();
                        var commonSmtpUrl = ImpersonateUser(userSmtps.First(), enableTrace, exchangeVersion);
                        if (commonSmtpUrl == null) userSmtps.Remove(firstUserSmtp);
                        // If the list contains other than the first one 
                        log += "2/2 Impersonating " + (userSmtps.Count - 1) + " userSmtps\n";

                        if (userSmtps.Count >= 1)
                        {
                            foreach (var userSmtp in userSmtps)
                            {
                                try
                                { //skip ther first one because it is already impersonated. 
                                    if (userSmtp == firstUserSmtp)
                                    {
                                        continue;
                                    }
                                    // Impersonate the users
                                    _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUsers:  Impersonating {0} ...", userSmtp);

                                        commonSmtpUrl = ImpersonateUser(userSmtp, enableTrace, exchangeVersion);

                                }
                                catch (Exception ex)
                                {
                                    _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUsers: Impersonating {1}\n exception {0}\n", ex.Message, userSmtp);
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUsers: exception {0}\n The exception occured after the following steps: \n{1}", ex.Message, log);
                    }
                }
        }

//
///模拟用户以便从他们那里获取信息。
/// 
///要模拟的用户列表
///从XML跟踪启用日志记录
///使用的Exchange服务器版本
公共无效模拟用户（ICollection用户SMTPS）
{
var log=“模拟用户\n”；
var firstUserSmtp=“”；
if（userSmtps！=null）
如果（userSmtps.Count>0）
{
//第一个smtp的url
/// <summary>
        /// To Impersonate users in order to get the info from them. 
        /// </summary>
        /// <param name="userSmtps">List of users to be impersonated</param>
        /// <param name="enableTrace"> To enable logging from the XML tracing</param>
        /// <param name="exchangeVersion">Exchange server version used </param>
        public void ImpersonateUsers(ICollection<string> userSmtps)
        {
            var log = "ImpersonateUsers\n";
            var firstUserSmtp = "";
            if (userSmtps != null)

                if (userSmtps.Count > 0)
                {

                    //the url for the first smtp
                    try
                    {
                        log += "1/2 Impersonating the first userSmtp\n";
                        _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUsers:  Getting the Url from the autodiscovery for the first smtp {0} ", userSmtps.First());
                        bool enableTrace = Services.First().Value.TraceEnabled;

                        ExchangeVersion exchangeVersion = Services.First().Value.RequestedServerVersion;
                        firstUserSmtp = userSmtps.First();
                        var commonSmtpUrl = ImpersonateUser(userSmtps.First(), enableTrace, exchangeVersion);
                        if (commonSmtpUrl == null) userSmtps.Remove(firstUserSmtp);
                        // If the list contains other than the first one 
                        log += "2/2 Impersonating " + (userSmtps.Count - 1) + " userSmtps\n";

                        if (userSmtps.Count >= 1)
                        {
                            foreach (var userSmtp in userSmtps)
                            {
                                try
                                { //skip ther first one because it is already impersonated. 
                                    if (userSmtp == firstUserSmtp)
                                    {
                                        continue;
                                    }
                                    // Impersonate the users
                                    _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUsers:  Impersonating {0} ...", userSmtp);

                                        commonSmtpUrl = ImpersonateUser(userSmtp, enableTrace, exchangeVersion);

                                }
                                catch (Exception ex)
                                {
                                    _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUsers: Impersonating {1}\n exception {0}\n", ex.Message, userSmtp);
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _logDevice.LogSrvMessage(1, "ExchangeLiteService: ImpersonateUsers: exception {0}\n The exception occured after the following steps: \n{1}", ex.Message, log);
                    }
                }
        }