/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding to use to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not valid. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
if (CodeAccessPermission.IsUnrestricted(esd))
{
this.flags = ReflectionPermissionFlag.AllFlags;
}
else
{
this.flags = ReflectionPermissionFlag.NoFlags;
string text = esd.Attributes["Flags"] as string;
if (text.IndexOf("MemberAccess") >= 0)
{
this.flags |= ReflectionPermissionFlag.MemberAccess;
}
if (text.IndexOf("ReflectionEmit") >= 0)
{
this.flags |= ReflectionPermissionFlag.ReflectionEmit;
}
if (text.IndexOf("TypeInformation") >= 0)
{
this.flags |= ReflectionPermissionFlag.TypeInformation;
}
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding to use to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not valid. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
this.m_userQuota = 0L;
this.m_machineQuota = 0L;
this.m_expirationDays = 0L;
this.m_permanentData = false;
this.m_allowed = IsolatedStorageContainment.None;
if (CodeAccessPermission.IsUnrestricted(esd))
{
this.UsageAllowed = IsolatedStorageContainment.UnrestrictedIsolatedStorage;
}
else
{
string text = esd.Attribute("Allowed");
if (text != null)
{
this.UsageAllowed = (IsolatedStorageContainment)((int)Enum.Parse(typeof(IsolatedStorageContainment), text));
}
text = esd.Attribute("UserQuota");
if (text != null)
{
Exception ex;
long.Parse(text, true, out this.m_userQuota, out ex);
}
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding to use to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not valid. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
if (CodeAccessPermission.IsUnrestricted(esd))
{
this._state = PermissionState.Unrestricted;
}
string text = esd.Attribute("Create");
if (text != null && text.Length > 0)
{
this.SetPathList(RegistryPermissionAccess.Create, text);
}
string text2 = esd.Attribute("Read");
if (text2 != null && text2.Length > 0)
{
this.SetPathList(RegistryPermissionAccess.Read, text2);
}
string text3 = esd.Attribute("Write");
if (text3 != null && text3.Length > 0)
{
this.SetPathList(RegistryPermissionAccess.Write, text3);
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding used to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not valid. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
if (CodeAccessPermission.IsUnrestricted(esd))
{
this._window = UIPermissionWindow.AllWindows;
this._clipboard = UIPermissionClipboard.AllClipboard;
}
else
{
string text = esd.Attribute("Window");
if (text == null)
{
this._window = UIPermissionWindow.NoWindows;
}
else
{
this._window = (UIPermissionWindow)((int)Enum.Parse(typeof(UIPermissionWindow), text));
}
string text2 = esd.Attribute("Clipboard");
if (text2 == null)
{
this._clipboard = UIPermissionClipboard.NoClipboard;
}
else
{
this._clipboard = (UIPermissionClipboard)((int)Enum.Parse(typeof(UIPermissionClipboard), text2));
}
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding to use to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not valid. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
string text = esd.Attribute("Site");
if (text != null)
{
this.Site = text;
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding to use to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not valid. </exception>
/// <PermissionSet>
/// <IPermission class="System.Security.Permissions.KeyContainerPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="Create" />
/// </PermissionSet>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
string text = esd.Attributes["X509v3Certificate"] as string;
if (text != null)
{
byte[] data = CryptoConvert.FromHex(text);
this.x509 = new X509Certificate(data);
}
}
public override void FromXml(SecurityElement securityElement)
{
CodeAccessPermission.CheckSecurityElement(securityElement, "securityElement", 1, 1);
if (CodeAccessPermission.IsUnrestricted(securityElement))
{
this._flags = KeyContainerPermissionFlags.AllFlags;
}
else
{
this._flags = (KeyContainerPermissionFlags)((int)Enum.Parse(typeof(KeyContainerPermissionFlags), securityElement.Attribute("Flags")));
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding to use to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not valid. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
string text = esd.Attribute("Zone");
if (text == null)
{
this.zone = SecurityZone.NoZone;
}
else
{
this.zone = (SecurityZone)((int)Enum.Parse(typeof(SecurityZone), text));
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding to use to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not valid. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
string text = esd.Attribute("Url");
if (text == null)
{
this.url = string.Empty;
}
else
{
this.Url = text;
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding used to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not compatible. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
if (CodeAccessPermission.IsUnrestricted(esd))
{
this.m_Unrestricted = true;
}
else
{
this.m_Unrestricted = false;
string text = esd.Attribute("Read");
if (text != null)
{
string[] array = text.Split(new char[]
{
';'
});
this.AddPathList(FileIOPermissionAccess.Read, array);
}
text = esd.Attribute("Write");
if (text != null)
{
string[] array = text.Split(new char[]
{
';'
});
this.AddPathList(FileIOPermissionAccess.Write, array);
}
text = esd.Attribute("Append");
if (text != null)
{
string[] array = text.Split(new char[]
{
';'
});
this.AddPathList(FileIOPermissionAccess.Append, array);
}
text = esd.Attribute("PathDiscovery");
if (text != null)
{
string[] array = text.Split(new char[]
{
';'
});
this.AddPathList(FileIOPermissionAccess.PathDiscovery, array);
}
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="e">The XML encoding to use to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="e" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="e" /> parameter is not a valid permission element.-or- The <paramref name="e" /> parameter's version number is not valid. </exception>
public override void FromXml(SecurityElement e)
{
CodeAccessPermission.CheckSecurityElement(e, "e", 1, 1);
this._list.Clear();
if (e.Children != null && e.Children.Count > 0)
{
foreach (object obj in e.Children)
{
SecurityElement se = (SecurityElement)obj;
this._list.Add(this.FromSecurityElement(se));
}
}
else
{
this._list.Add(this.FromSecurityElement(e));
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding to use to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not supported. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
if (CodeAccessPermission.IsUnrestricted(esd))
{
this.flags = SecurityPermissionFlag.AllFlags;
}
else
{
string text = esd.Attribute("Flags");
if (text == null)
{
this.flags = SecurityPermissionFlag.NoFlags;
}
else
{
this.flags = (SecurityPermissionFlag)((int)Enum.Parse(typeof(SecurityPermissionFlag), text));
}
}
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding used to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The version number of the <paramref name="esd" /> parameter is not supported. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
if (CodeAccessPermission.IsUnrestricted(esd))
{
this._access = FileDialogPermissionAccess.OpenSave;
}
else
{
string text = esd.Attribute("Access");
if (text == null)
{
this._access = FileDialogPermissionAccess.None;
}
else
{
this._access = (FileDialogPermissionAccess)((int)Enum.Parse(typeof(FileDialogPermissionAccess), text));
}
}
}
public override void FromXml(SecurityElement e)
{
CodeAccessPermission.CheckSecurityElement(e, "e", 1, 1);
this._resources = (HostProtectionResource)((int)Enum.Parse(typeof(HostProtectionResource), e.Attribute("Resources")));
}
/// <summary>Creates a permission from an XML encoding.</summary>
/// <param name="securityElement">A <see cref="T:System.Security.SecurityElement" /> that contains the XML encoding to use to create the permission. </param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="securityElement" />is null. </exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="securityElement" /> is not a valid permission element. -or- The version number of <paramref name="securityElement" /> is not valid. </exception>
public override void FromXml(SecurityElement securityElement)
{
CodeAccessPermission.CheckSecurityElement(securityElement, "securityElement", 1, 1);
}