public ExchangePrincipal FromUserSid(ADSessionSettings adSettings, SecurityIdentifier userSid, RemotingOptions remotingOptions)
{
Util.ThrowOnNullArgument(adSettings, "adSettings");
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
return(this.FromUserSid(adSettings.CreateRecipientSession(null), userSid, remotingOptions));
}
private ExchangePrincipal CreateExchangePrincipal(string displayName, IMailboxLocation mailboxLocation, RemotingOptions remotingOptions, string mailboxLegacyDN, Guid mailboxGuid, Guid mdbGuid, string primarySmtpAddress, ADObjectId id, OrganizationId orgId, IEnumerable <CultureInfo> preferredCultures, bool bypassRemoteCheck = false, RecipientType userRecipientType = RecipientType.Invalid, Guid?aggregatedMailboxGuid = null)
{
return(this.CreateExchangePrincipal(displayName, mailboxLocation, remotingOptions, mailboxLegacyDN, mailboxGuid, mdbGuid, primarySmtpAddress, id, orgId, preferredCultures, bypassRemoteCheck, userRecipientType, RecipientTypeDetails.None, null, false, aggregatedMailboxGuid));
}
private ExchangePrincipal CreateExchangePrincipal(string displayName, IMailboxLocation mailboxLocation, RemotingOptions remotingOptions, string mailboxLegacyDN, Guid mailboxGuid, Guid mdbGuid, string primarySmtpAddress, ADObjectId id, IEnumerable <CultureInfo> preferredCultures, RecipientType recipientType, SecurityIdentifier masterAccountSid, OrganizationId organizationId, bool isArchive = false)
{
return(this.CreateExchangePrincipal(displayName, mailboxLocation, remotingOptions, mailboxLegacyDN, mailboxGuid, mdbGuid, primarySmtpAddress, id, organizationId, preferredCultures, false, recipientType, RecipientTypeDetails.None, masterAccountSid, isArchive, null));
}
public ExchangePrincipal FromMiniRecipient(StorageMiniRecipient miniRecipient, RemotingOptions remotingOptions)
{
return(this.FromMiniRecipient(new MiniRecipientGenericWrapper(miniRecipient), remotingOptions));
}
private ExchangePrincipal CreateExchangePrincipal(IGenericADUser user, ADObjectId mdb, IMailboxLocation mailboxLocation, RemotingOptions remotingOptions, bool asArchive, Guid?aggregatedMailboxGuid, IDatabaseLocationProvider databaseLocationProvider, bool isContentIndexing = false)
{
ExchangePrincipalBuilder exchangePrincipalBuilder = ((remotingOptions & RemotingOptions.AllowHybridAccess) == RemotingOptions.AllowHybridAccess) ? new RemoteUserMailboxPrincipalBuilder(user) : this.GetExchangePrincipalBuilder(user);
exchangePrincipalBuilder.SetRemotingOptions(remotingOptions);
exchangePrincipalBuilder.SetDatabaseLocationProvider(databaseLocationProvider);
if (!mdb.IsNullOrEmpty())
{
exchangePrincipalBuilder.SetSelectedMailboxDatabase(mdb.ObjectGuid);
}
if (mailboxLocation != null)
{
exchangePrincipalBuilder.SetSelectedMailboxLocation(mailboxLocation);
}
if (asArchive)
{
exchangePrincipalBuilder.SelectArchiveMailbox();
}
exchangePrincipalBuilder.BypassRecipientTypeValidation(isContentIndexing);
if (aggregatedMailboxGuid != null && aggregatedMailboxGuid != Guid.Empty)
{
exchangePrincipalBuilder.SelectMailbox(aggregatedMailboxGuid.Value);
}
return(exchangePrincipalBuilder.Build());
}
public ExchangePrincipal FromMailboxData(ADSessionSettings adSessionSettings, string displayName, string serverFqdn, string serverLegacyDN, string mailboxLegacyDN, Guid mailboxGuid, Guid mdbGuid, string primarySmtpAddress, ADObjectId id, ICollection <CultureInfo> preferredCultures, IEnumerable <Guid> aggregatedMailboxGuids, RecipientType userRecipientType = RecipientType.Invalid, RemotingOptions remotingOptions = RemotingOptions.AllowCrossSite)
{
Util.ThrowOnNullArgument(displayName, "displayName");
Util.ThrowOnNullArgument(serverFqdn, "serverFqdn");
Util.ThrowOnNullArgument(serverLegacyDN, "serverLegacyDN");
Util.ThrowOnNullArgument(preferredCultures, "preferredCultures");
Util.ThrowOnNullArgument(aggregatedMailboxGuids, "aggregatedMailboxGuids");
if (displayName.Length == 0)
{
throw new ArgumentException("displayName has zero length", "displayName");
}
if (serverFqdn.Length == 0)
{
throw new ArgumentException("serverFqdn has zero length", "serverFqdn");
}
if (serverLegacyDN.Length == 0)
{
throw new ArgumentException("serverLegacyDN has zero length", "serverLegacyDN");
}
if (mdbGuid == Guid.Empty)
{
throw new ArgumentException("Should not be Empty", "mdbGuid");
}
if (string.IsNullOrEmpty(mailboxLegacyDN) && mailboxGuid == Guid.Empty)
{
throw new ArgumentException(ServerStrings.ExchangePrincipalFromMailboxDataError);
}
Guid?aggregatedMailboxGuid = aggregatedMailboxGuids.Any((Guid mailbox) => mailbox == mailboxGuid) ? new Guid?(mailboxGuid) : null;
return(this.CreateExchangePrincipal(displayName, this.CreateMailboxLocation(new DatabaseLocationInfo(serverFqdn, serverLegacyDN, null, null, false)), remotingOptions, mailboxLegacyDN, mailboxGuid, mdbGuid, primarySmtpAddress, id, (adSessionSettings != null) ? adSessionSettings.CurrentOrganizationId : null, preferredCultures, false, userRecipientType, aggregatedMailboxGuid));
}
public ExchangePrincipal FromMailboxData(Guid mailboxGuid, Guid mdbGuid, OrganizationId organizationId, ICollection <CultureInfo> preferredCultures, RemotingOptions remotingOptions)
{
return(this.FromMailboxData(mailboxGuid, mdbGuid, organizationId, preferredCultures, remotingOptions, null));
}
public ExchangePrincipal FromLegacyDNByMiniRecipient(ADSessionSettings adSettings, string legacyDN, RemotingOptions remotingOptions, PropertyDefinition[] miniRecipientProperties, out StorageMiniRecipient miniRecipient)
{
Util.ThrowOnNullArgument(adSettings, "adSettings");
return(this.FromLegacyDNByMiniRecipient(adSettings.CreateRecipientSession(null), legacyDN, remotingOptions, miniRecipientProperties, out miniRecipient));
}
public ExchangePrincipal FromLegacyDNByMiniRecipient(IRecipientSession recipientSession, string legacyDN, RemotingOptions remotingOptions, PropertyDefinition[] miniRecipientProperties, out StorageMiniRecipient miniRecipient)
{
Util.ThrowOnNullArgument(recipientSession, "recipientSession");
Util.ThrowOnNullArgument(legacyDN, "legacyDN");
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
if (legacyDN.Length == 0)
{
throw new ArgumentException("legacyDN has zero length", "legacyDN");
}
Guid mbxGuid;
legacyDN = this.TryToExtractArchiveOrAggregatedMailboxGuid(legacyDN, out mbxGuid);
IGenericADUser genericADUser = this.directoryAccessor.FindMiniRecipientByProxyAddress(recipientSession, ProxyAddressPrefix.LegacyDN.GetProxyAddress(legacyDN, true), miniRecipientProperties, out miniRecipient);
if (genericADUser == null)
{
throw new ObjectNotFoundException(ServerStrings.ADUserNotFound);
}
ADObjectId mdb;
bool asArchive = this.UpdateArchiveStatus(mbxGuid, genericADUser, out mdb);
Guid? aggregatedMailboxGuid = null;
if (genericADUser.AggregatedMailboxGuids != null)
{
aggregatedMailboxGuid = (genericADUser.AggregatedMailboxGuids.Any((Guid mailbox) => mailbox == mbxGuid) ? new Guid?(mbxGuid) : null);
}
IMailboxLocation mailboxLocation = new OnDemandMailboxLocation(() => new MailboxDatabaseLocation(this.databaseLocationProvider.GetLocationInfo(mdb.ObjectGuid, false, (remotingOptions & RemotingOptions.AllowCrossSite) == RemotingOptions.AllowCrossSite)));
ExchangePrincipal exchangePrincipal = this.InternalFromMiniRecipient(genericADUser, mdb, mailboxLocation, remotingOptions, asArchive, aggregatedMailboxGuid);
if (mbxGuid != Guid.Empty && !exchangePrincipal.MailboxInfo.IsAggregated && !exchangePrincipal.MailboxInfo.IsArchive)
{
throw new ObjectNotFoundException(ServerStrings.AggregatedMailboxNotFound(mbxGuid.ToString()));
}
return(exchangePrincipal);
}
public ExchangePrincipal FromLegacyDN(ADSessionSettings adSettings, string legacyDN, RemotingOptions remotingOptions)
{
Util.ThrowOnNullArgument(adSettings, "adSettings");
return(this.FromLegacyDN(adSettings.CreateRecipientSession(null), legacyDN, remotingOptions));
}
public ExchangePrincipal FromLegacyDN(IRecipientSession recipientSession, string legacyDN, RemotingOptions remotingOptions)
{
Util.ThrowOnNullArgument(recipientSession, "recipientSession");
Util.ThrowOnNullArgument(legacyDN, "legacyDN");
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
if (legacyDN.Length == 0)
{
throw new ObjectNotFoundException(ServerStrings.ADUserNotFound);
}
Guid mbxGuid;
legacyDN = this.TryToExtractArchiveOrAggregatedMailboxGuid(legacyDN, out mbxGuid);
IGenericADUser genericADUser = this.directoryAccessor.FindByLegacyExchangeDn(recipientSession, legacyDN);
if (genericADUser == null)
{
throw new ObjectNotFoundException(ServerStrings.ADUserNotFound);
}
ADObjectId mdb;
bool asArchive = this.UpdateArchiveStatus(mbxGuid, genericADUser, out mdb);
Guid? aggregatedMailboxGuid = null;
if (mbxGuid != Guid.Empty && genericADUser.ArchiveGuid != mbxGuid)
{
if (genericADUser.AggregatedMailboxGuids != null)
{
aggregatedMailboxGuid = (genericADUser.AggregatedMailboxGuids.Any((Guid mailbox) => mailbox == mbxGuid) ? new Guid?(mbxGuid) : null);
}
if (aggregatedMailboxGuid == null && genericADUser.MailboxLocations != null)
{
aggregatedMailboxGuid = (genericADUser.MailboxLocations.Any((IMailboxLocationInfo mailbox) => mailbox.MailboxGuid.Equals(mbxGuid)) ? new Guid?(mbxGuid) : null);
}
}
ExchangePrincipal exchangePrincipal = this.InternalFromADUser(genericADUser, mdb, null, remotingOptions, asArchive, false, aggregatedMailboxGuid);
if (mbxGuid != Guid.Empty && !exchangePrincipal.MailboxInfo.MailboxGuid.Equals(mbxGuid))
{
throw new ObjectNotFoundException(ServerStrings.AggregatedMailboxNotFound(mbxGuid.ToString()));
}
return(exchangePrincipal);
}
public ExchangePrincipal FromProxyAddress(IRecipientSession session, string proxyAddress, RemotingOptions remotingOptions)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(proxyAddress, "proxyAddress");
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
if (proxyAddress.Length == 0)
{
throw new ObjectNotFoundException(ServerStrings.ADUserNotFound);
}
this.CheckNoCrossPremiseAccess(remotingOptions);
ProxyAddress proxyAddress2 = ProxyAddress.Parse(proxyAddress);
IGenericADUser genericADUser = this.directoryAccessor.FindByProxyAddress(session, proxyAddress2);
if (genericADUser == null)
{
throw new ObjectNotFoundException(ServerStrings.ADUserNotFound);
}
ADObjectId mdb;
bool asArchive = this.UpdateArchiveStatus(genericADUser.MailboxGuid, genericADUser, out mdb);
return(this.InternalFromADUser(genericADUser, mdb, null, remotingOptions, asArchive, false, null));
}
public ExchangePrincipal FromProxyAddress(ADSessionSettings adSettings, string proxyAddress, RemotingOptions remotingOptions)
{
Util.ThrowOnNullArgument(adSettings, "adSettings");
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
return(this.FromProxyAddress(adSettings.CreateRecipientSession(null), proxyAddress, remotingOptions));
}
public ExchangePrincipal FromUserSid(IRecipientSession recipientSession, SecurityIdentifier userSid, RemotingOptions remotingOptions)
{
Util.ThrowOnNullArgument(recipientSession, "recipientSession");
Util.ThrowOnNullArgument(userSid, "userSid");
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
this.CheckNoCrossPremiseAccess(remotingOptions);
IGenericADUser genericADUser = this.directoryAccessor.FindBySid(recipientSession, userSid);
if (genericADUser == null)
{
throw new ObjectNotFoundException(ServerStrings.ADUserNotFound);
}
return(this.InternalFromADUser(genericADUser, remotingOptions));
}
public ExchangePrincipal FromAnyVersionMailboxData(string displayName, Guid mailboxGuid, Guid mdbGuid, string primarySmtpAddress, string legacyExchangeDN, ADObjectId id, RecipientType recipientType, SecurityIdentifier masterAccountSid, OrganizationId organizationId, RemotingOptions remotingOptions, bool isArchive)
{
EnumValidator.ThrowIfInvalid <RecipientType>(recipientType, "recipientType");
try
{
DatabaseLocationInfo locationInfo = this.databaseLocationProvider.GetLocationInfo(mdbGuid, false, (remotingOptions & RemotingOptions.AllowCrossSite) == RemotingOptions.AllowCrossSite);
return(this.CreateExchangePrincipal(displayName, this.CreateMailboxLocation(locationInfo), remotingOptions, legacyExchangeDN, mailboxGuid, mdbGuid, primarySmtpAddress, id, Array <CultureInfo> .Empty, recipientType, masterAccountSid, organizationId, isArchive));
}
catch (DatabaseNotFoundException)
{
ExTraceGlobals.StorageTracer.TraceError <Guid>(0L, "Database was not found for mailbox {0}.", mailboxGuid);
}
catch (UnableToFindServerForDatabaseException)
{
ExTraceGlobals.SessionTracer.TraceError <Guid>(0L, "Server was not found for Database {0}.", mdbGuid);
}
return(null);
}
public ExchangePrincipal FromMailboxGuid(ADSessionSettings adSettings, Guid mailboxGuid, RemotingOptions remotingOptions, string domainController = null)
{
return(this.FromMailboxGuid(adSettings, mailboxGuid, Guid.Empty, remotingOptions, domainController, false));
}
public ExchangePrincipal FromADUser(ADSessionSettings adSettings, ADUser user, RemotingOptions remotingOptions, string domainController = null)
{
Util.ThrowOnNullArgument(user, "user");
return(this.FromADUser(adSettings, new ADUserGenericWrapper(user), remotingOptions, domainController));
}
public ExchangePrincipal FromMailboxGuid(ADSessionSettings adSettings, Guid mailboxGuid, Guid mdbGuid, RemotingOptions remotingOptions, string domainController = null, bool isContentIndexing = false)
{
Util.ThrowOnNullArgument(adSettings, "adSettings");
return(this.FromMailboxGuid(adSettings.CreateRecipientSession(domainController), mailboxGuid, mdbGuid, remotingOptions, isContentIndexing));
}
public ExchangePrincipal FromADUser(ADSessionSettings adSettings, IGenericADUser user, RemotingOptions remotingOptions, string domainController = null)
{
Util.ThrowOnNullArgument(adSettings, "adSettings");
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
Util.ThrowOnNullArgument(user, "user");
return(this.InternalFromADUser(user, remotingOptions));
}
public ExchangePrincipal FromMailboxGuid(IRecipientSession recipientSession, Guid mailboxGuid, Guid mdbGuid, RemotingOptions remotingOptions, bool isContentIndexing = false)
{
Util.ThrowOnNullArgument(recipientSession, "recipientSession");
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
if (mailboxGuid == Guid.Empty)
{
throw new ArgumentException("Guid-less mailboxes are not supported by this factory method", "mailboxGuid");
}
IGenericADUser genericADUser = this.directoryAccessor.FindByExchangeGuid(recipientSession, mailboxGuid, false);
if (genericADUser == null)
{
throw new ObjectNotFoundException(ServerStrings.ADUserNotFound);
}
ADObjectId mdb;
bool asArchive = this.UpdateArchiveStatus(mailboxGuid, genericADUser, out mdb);
if (mdbGuid != Guid.Empty)
{
mdb = new ADObjectId(mdbGuid);
}
return(this.InternalFromADUser(genericADUser, mdb, null, remotingOptions, asArchive, isContentIndexing, new Guid?(mailboxGuid)));
}
public ExchangePrincipal FromMailboxData(Guid mailboxGuid, Guid mdbGuid, OrganizationId organizationId, ICollection <CultureInfo> preferredCultures, RemotingOptions remotingOptions, DatabaseLocationInfo databaseLocationInfo)
{
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
if (mailboxGuid == Guid.Empty)
{
throw new ArgumentException("Should not be empty", "mailboxGuid");
}
if (mdbGuid == Guid.Empty)
{
throw new ArgumentException("Should not be empty", "mdbGuid");
}
return(this.CreateExchangePrincipal(mailboxGuid.ToString(), this.CreateMailboxLocation(databaseLocationInfo ?? this.databaseLocationProvider.GetLocationInfo(mdbGuid, false, (remotingOptions & RemotingOptions.AllowCrossSite) == RemotingOptions.AllowCrossSite)), remotingOptions, string.Empty, mailboxGuid, mdbGuid, string.Empty, null, organizationId, preferredCultures, false, RecipientType.Invalid, null));
}
public ExchangePrincipal FromADUser(IGenericADUser user, RemotingOptions remotingOptions)
{
Util.ThrowOnNullArgument(user, "user");
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
return(this.InternalFromADUser(user, remotingOptions));
}
private ExchangePrincipal InternalFromMiniRecipient(IGenericADUser adUser, ADObjectId mdb, IMailboxLocation mailboxLocation, RemotingOptions remotingOptions, bool asArchive, Guid?aggregatedMailboxGuid = null)
{
if (adUser == null)
{
throw new ObjectNotFoundException(ServerStrings.ADUserNotFound);
}
if (mdb == null)
{
mdb = adUser.MailboxDatabase;
}
if (mailboxLocation == null && mdb != null)
{
mailboxLocation = this.CreateMailboxLocation(this.databaseLocationProvider.GetLocationInfo(mdb.ObjectGuid, false, (remotingOptions & RemotingOptions.AllowCrossSite) == RemotingOptions.AllowCrossSite));
}
return(this.CreateExchangePrincipal(adUser, mdb, mailboxLocation, remotingOptions, asArchive, aggregatedMailboxGuid, this.databaseLocationProvider, false));
}
public ExchangePrincipal FromDirectoryObjectId(IRecipientSession session, ADObjectId directoryEntry, RemotingOptions remoteOptions = RemotingOptions.LocalConnectionsOnly)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(directoryEntry, "directoryEntry");
IGenericADUser genericADUser = this.directoryAccessor.FindByObjectId(session, directoryEntry);
if (genericADUser == null)
{
throw new ObjectNotFoundException(ServerStrings.ADUserNotFound);
}
return(this.InternalFromADUser(genericADUser, remoteOptions));
}
public ExchangePrincipal FromADUser(ADUser user, DatabaseLocationInfo databaseLocationInfo, RemotingOptions remotingOptions)
{
Util.ThrowOnNullArgument(user, "user");
return(this.FromADUser(new ADUserGenericWrapper(user), databaseLocationInfo, remotingOptions));
}
private ExchangePrincipal InternalFromADUser(IGenericADUser user, ADObjectId mdb, DatabaseLocationInfo databaseLocationInfo, RemotingOptions remotingOptions)
{
return(this.InternalFromADUser(user, mdb, databaseLocationInfo, remotingOptions, false, false, null));
}
private ExchangePrincipal CreateExchangePrincipal(string displayName, IMailboxLocation mailboxLocation, RemotingOptions remotingOptions, string mailboxLegacyDN, Guid mailboxGuid, Guid mdbGuid, string primarySmtpAddress, ADObjectId id, OrganizationId orgId, IEnumerable <CultureInfo> preferredCultures, bool bypassRemoteCheck, RecipientType recipientType, RecipientTypeDetails recipientTypeDetails, SecurityIdentifier masterAccountSid = null, bool isArchive = false, Guid?aggregatedMailboxGuid = null)
{
ADObjectId adobjectId = new ADObjectId(mdbGuid);
IGenericADUser recipient = new GenericADUser
{
MailboxDatabase = (isArchive ? null : adobjectId),
ArchiveDatabase = (isArchive ? adobjectId : null),
LegacyDn = mailboxLegacyDN,
OrganizationId = orgId,
DisplayName = displayName,
PrimarySmtpAddress = new SmtpAddress(primarySmtpAddress),
MailboxGuid = (isArchive ? Guid.Empty : mailboxGuid),
ArchiveGuid = (isArchive ? mailboxGuid : Guid.Empty),
Languages = preferredCultures,
RecipientType = recipientType,
RecipientTypeDetails = recipientTypeDetails,
ObjectId = id,
MasterAccountSid = masterAccountSid,
AggregatedMailboxGuids = ((aggregatedMailboxGuid != null) ? new Guid[]
{
aggregatedMailboxGuid.Value
} : Array <Guid> .Empty)
};
ExchangePrincipalBuilder exchangePrincipalBuilder = this.GetExchangePrincipalBuilder(recipient);
exchangePrincipalBuilder.SetRemotingOptions(remotingOptions);
exchangePrincipalBuilder.BypassRecipientTypeValidation(true);
if (mailboxLocation != null)
{
exchangePrincipalBuilder.SetSelectedMailboxLocation(mailboxLocation);
}
if (isArchive)
{
exchangePrincipalBuilder.SelectArchiveMailbox();
}
if (aggregatedMailboxGuid != null && aggregatedMailboxGuid != Guid.Empty)
{
exchangePrincipalBuilder.SelectMailbox(aggregatedMailboxGuid.Value);
}
return(exchangePrincipalBuilder.Build());
}
private ExchangePrincipal InternalFromADUser(IGenericADUser user, ADObjectId mdb, DatabaseLocationInfo databaseLocationInfo, RemotingOptions remotingOptions, bool asArchive, bool isContentIndexing = false, Guid?aggregatedMailboxGuid = null)
{
if (databaseLocationInfo == null && mdb != null)
{
databaseLocationInfo = this.databaseLocationProvider.GetLocationInfo(mdb.ObjectGuid, false, (remotingOptions & RemotingOptions.AllowCrossSite) == RemotingOptions.AllowCrossSite);
}
return(this.CreateExchangePrincipal(user, mdb, this.CreateMailboxLocation(databaseLocationInfo), remotingOptions, asArchive, aggregatedMailboxGuid, this.databaseLocationProvider, isContentIndexing));
}
public ExchangePrincipal FromADUser(IGenericADUser user, DatabaseLocationInfo databaseLocationInfo, RemotingOptions remotingOptions)
{
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
Util.ThrowOnNullArgument(user, "user");
ADObjectId mdb;
bool asArchive = this.UpdateArchiveStatus(user.MailboxGuid, user, out mdb);
return(this.InternalFromADUser(user, mdb, databaseLocationInfo, remotingOptions, asArchive, false, null));
}
public ExchangePrincipal FromWindowsIdentity(IRecipientSession recipientSession, WindowsIdentity windowsIdentity, RemotingOptions remotingOptions)
{
EnumValidator.ThrowIfInvalid <RemotingOptions>(remotingOptions, "remotingOptions");
Util.ThrowOnNullArgument(windowsIdentity, "windowsIdentity");
return(this.FromUserSid(recipientSession, windowsIdentity.User, remotingOptions));
}
