public override void FromXml(SecurityElement securityElement)
{
if (securityElement == null)
{
throw new ArgumentNullException("securityElement");
}
string className = securityElement.Attribute("class");
if (className == null || className.IndexOf(this.GetType().FullName, StringComparison.Ordinal) == -1)
{
throw new ArgumentException(SecurityResources.GetResourceString("Argument_InvalidClassAttribute"), "securityElement");
}
string unrestricted = securityElement.Attribute("Unrestricted");
if (unrestricted != null && String.Compare(unrestricted, "true", StringComparison.OrdinalIgnoreCase) == 0)
{
m_flags = DataProtectionPermissionFlags.AllFlags;
return;
}
m_flags = DataProtectionPermissionFlags.NoFlags;
string strFlags = securityElement.Attribute("Flags");
if (strFlags != null)
{
DataProtectionPermissionFlags flags = (DataProtectionPermissionFlags)Enum.Parse(typeof(DataProtectionPermissionFlags), strFlags);
VerifyFlags(flags);
m_flags = flags;
}
}
public override void FromXml(SecurityElement securityElement)
{
if (securityElement == null)
{
throw new ArgumentNullException("securityElement");
}
string str = securityElement.Attribute("class");
if ((str == null) || (str.IndexOf(base.GetType().FullName, StringComparison.Ordinal) == -1))
{
throw new ArgumentException(SecurityResources.GetResourceString("Argument_InvalidClassAttribute"), "securityElement");
}
string strA = securityElement.Attribute("Unrestricted");
if ((strA != null) && (string.Compare(strA, "true", StringComparison.OrdinalIgnoreCase) == 0))
{
this.m_flags = DataProtectionPermissionFlags.AllFlags;
}
else
{
this.m_flags = DataProtectionPermissionFlags.NoFlags;
string str3 = securityElement.Attribute("Flags");
if (str3 != null)
{
DataProtectionPermissionFlags flags = (DataProtectionPermissionFlags)Enum.Parse(typeof(DataProtectionPermissionFlags), str3);
VerifyFlags(flags);
this.m_flags = flags;
}
}
}
public override void FromXml(SecurityElement securityElement)
{
if (securityElement == null)
{
throw new ArgumentNullException("securityElement");
}
string str = securityElement.Attribute("class");
if ((str == null) || (str.IndexOf(base.GetType().FullName, StringComparison.Ordinal) == -1))
{
throw new ArgumentException(SecurityResources.GetResourceString("Argument_InvalidClassAttribute"), "securityElement");
}
string strA = securityElement.Attribute("Unrestricted");
if ((strA != null) && (string.Compare(strA, "true", StringComparison.OrdinalIgnoreCase) == 0))
{
this.m_flags = DataProtectionPermissionFlags.AllFlags;
}
else
{
this.m_flags = DataProtectionPermissionFlags.NoFlags;
string str3 = securityElement.Attribute("Flags");
if (str3 != null)
{
DataProtectionPermissionFlags flags = (DataProtectionPermissionFlags) Enum.Parse(typeof(DataProtectionPermissionFlags), str3);
VerifyFlags(flags);
this.m_flags = flags;
}
}
}
public DataProtectionPermission(PermissionState state)
{
if (PermissionHelper.CheckPermissionState(state, true) == PermissionState.Unrestricted)
{
_flags = DataProtectionPermissionFlags.AllFlags;
}
}
public DataProtectionPermission (PermissionState state)
{
if (PermissionHelper.CheckPermissionState (state, true) == PermissionState.Unrestricted)
_flags = DataProtectionPermissionFlags.AllFlags;
else
_flags = DataProtectionPermissionFlags.NoFlags;
}
internal static void VerifyFlags(DataProtectionPermissionFlags flags)
{
if ((flags & ~DataProtectionPermissionFlags.AllFlags) != 0)
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SecurityResources.GetResourceString("Arg_EnumIllegalVal"), (int)flags));
}
}
public DataProtectionPermission (PermissionState state) {
if (state == PermissionState.Unrestricted)
m_flags = DataProtectionPermissionFlags.AllFlags;
else if (state == PermissionState.None)
m_flags = DataProtectionPermissionFlags.NoFlags;
else
throw new ArgumentException(SecurityResources.GetResourceString("Argument_InvalidPermissionState"));
}
public static void DataProtectionPermissionAttributeCallMethods()
{
var dpa = new DataProtectionPermissionAttribute(new SecurityAction());
DataProtectionPermissionFlags flags = dpa.Flags;
bool protectData = dpa.ProtectData;
bool unprotectData = dpa.UnprotectData;
bool protectMemory = dpa.ProtectMemory;
bool unprotectMemory = dpa.UnprotectMemory;
IPermission ip = dpa.CreatePermission();
}
public override void FromXml(SecurityElement e)
{
// General validation in CodeAccessPermission
PermissionHelper.CheckSecurityElement(e, "e", version, version);
// Note: we do not (yet) care about the return value
// as we only accept version 1 (min/max values)
_flags = (DataProtectionPermissionFlags)Enum.Parse(
typeof(DataProtectionPermissionFlags), e.Attribute("Flags"));
}
public static void DataProtectionPermissionCallMethods()
{
DataProtectionPermission dp = new DataProtectionPermission(new PermissionState());
bool isunrestricted = dp.IsUnrestricted();
DataProtectionPermissionFlags flags = dp.Flags;
IPermission other = new DataProtectionPermission(flags);
other = dp.Copy();
other = dp.Union(other);
other = dp.Intersect(other);
bool isSubsetOf = dp.IsSubsetOf(other);
SecurityElement se = dp.ToXml();
dp.FromXml(se);
}
public DataProtectionPermission(PermissionState state)
{
if (state == PermissionState.Unrestricted)
{
m_flags = DataProtectionPermissionFlags.AllFlags;
}
else if (state == PermissionState.None)
{
m_flags = DataProtectionPermissionFlags.NoFlags;
}
else
{
throw new ArgumentException(SecurityResources.GetResourceString("Argument_InvalidPermissionState"));
}
}
public override bool IsSubsetOf(IPermission target)
{
if (target == null)
{
return(m_flags == DataProtectionPermissionFlags.NoFlags);
}
try {
DataProtectionPermission operand = (DataProtectionPermission)target;
DataProtectionPermissionFlags sourceFlag = this.m_flags;
DataProtectionPermissionFlags targetFlag = operand.m_flags;
return((sourceFlag & targetFlag) == sourceFlag);
}
catch (InvalidCastException) {
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SecurityResources.GetResourceString("Argument_WrongType"), this.GetType().FullName));
}
}
public override bool IsSubsetOf(IPermission target)
{
bool flag;
if (target == null)
{
return(this.m_flags == DataProtectionPermissionFlags.NoFlags);
}
try
{
DataProtectionPermission permission = (DataProtectionPermission)target;
DataProtectionPermissionFlags flags = this.m_flags;
DataProtectionPermissionFlags flags2 = permission.m_flags;
flag = (flags & flags2) == flags;
}
catch (InvalidCastException)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SecurityResources.GetResourceString("Argument_WrongType"), new object[] { base.GetType().FullName }));
}
return(flag);
}
//
// IPermission implementation
//
public override IPermission Union(IPermission target)
{
if (target == null)
{
return(this.Copy());
}
try {
DataProtectionPermission operand = (DataProtectionPermission)target;
DataProtectionPermissionFlags flag_union = m_flags | operand.m_flags;
if (flag_union == DataProtectionPermissionFlags.NoFlags)
{
return(null);
}
else
{
return(new DataProtectionPermission(flag_union));
}
}
catch (InvalidCastException) {
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SecurityResources.GetResourceString("Argument_WrongType"), this.GetType().FullName));
}
}
public override IPermission Intersect(IPermission target)
{
IPermission permission2;
if (target == null)
{
return(null);
}
try
{
DataProtectionPermission permission = (DataProtectionPermission)target;
DataProtectionPermissionFlags flag = permission.m_flags & this.m_flags;
if (flag == DataProtectionPermissionFlags.NoFlags)
{
return(null);
}
permission2 = new DataProtectionPermission(flag);
}
catch (InvalidCastException)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SecurityResources.GetResourceString("Argument_WrongType"), new object[] { base.GetType().FullName }));
}
return(permission2);
}
public DataProtectionPermission (DataProtectionPermissionFlags flags)
{
// reuse validation by the Flags property
Flags = flags;
}
public DataProtectionPermission(DataProtectionPermissionFlags flag)
{
}
public override void FromXml (SecurityElement e)
{
// General validation in CodeAccessPermission
PermissionHelper.CheckSecurityElement (e, "e", version, version);
// Note: we do not (yet) care about the return value
// as we only accept version 1 (min/max values)
_flags = (DataProtectionPermissionFlags) Enum.Parse (
typeof (DataProtectionPermissionFlags), e.Attribute ("Flags"));
}
public DataProtectionPermission(DataProtectionPermissionFlags flags)
{
// reuse validation by the Flags property
Flags = flags;
}
public DataProtectionPermission(DataProtectionPermissionFlags flag)
{
this.Flags = flag;
}
public DataProtectionPermissionAttribute (SecurityAction action)
: base (action)
{
_flags = DataProtectionPermissionFlags.NoFlags;
}
public DataProtectionPermission(DataProtectionPermissionFlags flag) {}
internal static void VerifyFlags(DataProtectionPermissionFlags flags)
{
if ((flags & ~DataProtectionPermissionFlags.AllFlags) != DataProtectionPermissionFlags.NoFlags)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SecurityResources.GetResourceString("Arg_EnumIllegalVal"), new object[] { (int) flags }));
}
}
public DataProtectionPermission(DataProtectionPermissionFlags flag)
{
this.Flags = flag;
}
public override void FromXml (SecurityElement securityElement) {
if (securityElement == null)
throw new ArgumentNullException("securityElement");
string className = securityElement.Attribute("class");
if (className == null || className.IndexOf(this.GetType().FullName, StringComparison.Ordinal) == -1)
throw new ArgumentException(SecurityResources.GetResourceString("Argument_InvalidClassAttribute"), "securityElement");
string unrestricted = securityElement.Attribute("Unrestricted");
if (unrestricted != null && String.Compare(unrestricted, "true", StringComparison.OrdinalIgnoreCase) == 0) {
m_flags = DataProtectionPermissionFlags.AllFlags;
return;
}
m_flags = DataProtectionPermissionFlags.NoFlags;
string strFlags = securityElement.Attribute("Flags");
if (strFlags != null) {
DataProtectionPermissionFlags flags = (DataProtectionPermissionFlags) Enum.Parse(typeof(DataProtectionPermissionFlags), strFlags);
VerifyFlags(flags);
m_flags = flags;
}
}
