public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag) { VerifyWindowFlag(windowFlag); VerifyClipboardFlag(clipboardFlag); this.m_windowFlag = windowFlag; this.m_clipboardFlag = clipboardFlag; }
/// <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)); } } }
public override IPermission Intersect(IPermission target) { if (target == null) { return(null); } else if (!VerifyType(target)) { throw new ArgumentException( String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName) ); } UIPermission operand = (UIPermission)target; UIPermissionWindow isectWindowFlags = m_windowFlag < operand.m_windowFlag ? m_windowFlag : operand.m_windowFlag; UIPermissionClipboard isectClipboardFlags = m_clipboardFlag < operand.m_clipboardFlag ? m_clipboardFlag : operand.m_clipboardFlag; if (isectWindowFlags == UIPermissionWindow.NoWindows && isectClipboardFlags == UIPermissionClipboard.NoClipboard) { return(null); } else { return(new UIPermission(isectWindowFlags, isectClipboardFlags)); } }
// Constructors public UIPermission (PermissionState state) { if (CheckPermissionState (state, true) == PermissionState.Unrestricted) { _clipboard = UIPermissionClipboard.AllClipboard; _window = UIPermissionWindow.AllWindows; } }
/// <summary>用指定的窗口和剪贴板权限初始化 <see cref="T:System.Security.Permissions.UIPermission" /> 类的新实例。</summary> /// <param name="windowFlag">枚举值之一。</param> /// <param name="clipboardFlag">枚举值之一。</param> /// <exception cref="T:System.ArgumentException"> /// <paramref name="windowFlag" /> 参数不是有效的 <see cref="T:System.Security.Permissions.UIPermissionWindow" /> 值。- 或 -<paramref name="clipboardFlag" /> 参数不是有效的 <see cref="T:System.Security.Permissions.UIPermissionClipboard" /> 值。</exception> public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag) { UIPermission.VerifyWindowFlag(windowFlag); UIPermission.VerifyClipboardFlag(clipboardFlag); this.m_windowFlag = windowFlag; this.m_clipboardFlag = clipboardFlag; }
private static void VerifyClipboardFlag(UIPermissionClipboard flag) { if (flag < UIPermissionClipboard.NoClipboard || flag > UIPermissionClipboard.AllClipboard) { throw new ArgumentException(String.Format(Environment.GetResourceString("Arg_EnumIllegalVal"), (int)flag)); } }
public override IPermission Union(IPermission target) { if (target == null) { return(this.Copy()); } else if (!VerifyType(target)) { throw new ArgumentException( Environment.GetResourceString("Argument_WrongType", this.GetType().FullName) ); } UIPermission operand = (UIPermission)target; UIPermissionWindow isectWindowFlags = m_windowFlag > operand.m_windowFlag ? m_windowFlag : operand.m_windowFlag; UIPermissionClipboard isectClipboardFlags = m_clipboardFlag > operand.m_clipboardFlag ? m_clipboardFlag : operand.m_clipboardFlag; if (isectWindowFlags == UIPermissionWindow.NoWindows && isectClipboardFlags == UIPermissionClipboard.NoClipboard) { return(null); } else { return(new UIPermission(isectWindowFlags, isectClipboardFlags)); } }
public override void FromXml(SecurityElement esd) { CodeAccessPermission.ValidateElement(esd, this); if (XMLUtil.IsUnrestricted(esd)) { SetUnrestricted(true); return; } m_windowFlag = UIPermissionWindow.NoWindows; m_clipboardFlag = UIPermissionClipboard.NoClipboard; String window = esd.Attribute("Window"); if (window != null) { m_windowFlag = (UIPermissionWindow)Enum.Parse(typeof(UIPermissionWindow), window); } String clipboard = esd.Attribute("Clipboard"); if (clipboard != null) { m_clipboardFlag = (UIPermissionClipboard)Enum.Parse(typeof(UIPermissionClipboard), clipboard); } }
public override void FromXml(SecurityElement esd) { // General validation in CodeAccessPermission CheckSecurityElement(esd, "esd", version, version); // Note: we do not (yet) care about the return value // as we only accept version 1 (min/max values) if (IsUnrestricted(esd)) { _window = UIPermissionWindow.AllWindows; _clipboard = UIPermissionClipboard.AllClipboard; } else { string w = esd.Attribute("Window"); if (w == null) { _window = UIPermissionWindow.NoWindows; } else { _window = (UIPermissionWindow)Enum.Parse(typeof(UIPermissionWindow), w); } string c = esd.Attribute("Clipboard"); if (c == null) { _clipboard = UIPermissionClipboard.NoClipboard; } else { _clipboard = (UIPermissionClipboard)Enum.Parse(typeof(UIPermissionClipboard), c); } } }
private static void VerifyClipboardFlag(UIPermissionClipboard flag) { if ((flag < UIPermissionClipboard.NoClipboard) || (flag > UIPermissionClipboard.AllClipboard)) { throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { (int)flag })); } }
public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag) { VerifyWindowFlag(windowFlag); VerifyClipboardFlag(clipboardFlag); m_windowFlag = windowFlag; m_clipboardFlag = clipboardFlag; }
/// <summary>Initializes a new instance of the <see cref="T:System.Security.Permissions.UIPermission" /> class with either fully restricted or unrestricted access, as specified.</summary> /// <param name="state">One of the <see cref="T:System.Security.Permissions.PermissionState" /> values. </param> /// <exception cref="T:System.ArgumentException">The <paramref name="state" /> parameter is not a valid <see cref="T:System.Security.Permissions.PermissionState" />. </exception> public UIPermission(PermissionState state) { if (CodeAccessPermission.CheckPermissionState(state, true) == PermissionState.Unrestricted) { this._clipboard = UIPermissionClipboard.AllClipboard; this._window = UIPermissionWindow.AllWindows; } }
private void SetUnrestricted(bool unrestricted) { if (unrestricted) { m_windowFlag = UIPermissionWindow.AllWindows; m_clipboardFlag = UIPermissionClipboard.AllClipboard; } }
// Constructors public UIPermission(PermissionState state) { if (CheckPermissionState(state, true) == PermissionState.Unrestricted) { _clipboard = UIPermissionClipboard.AllClipboard; _window = UIPermissionWindow.AllWindows; } }
private void SetUnrestricted(bool unrestricted) { if (!unrestricted) { return; } this.m_windowFlag = UIPermissionWindow.AllWindows; this.m_clipboardFlag = UIPermissionClipboard.AllClipboard; }
public UIPermission(UIPermissionClipboard clipboardFlag) { if (clipboardFlag < UIPermissionClipboard.NoClipboard || clipboardFlag > UIPermissionClipboard.AllClipboard) { throw new ArgumentException(_("Arg_ClipboardFlag")); } window = UIPermissionWindow.NoWindows; clipboard = clipboardFlag; }
public UIPermission(UIPermissionWindow windowFlag) { if (windowFlag < UIPermissionWindow.NoWindows || windowFlag > UIPermissionWindow.AllWindows) { throw new ArgumentException(_("Arg_WindowFlag")); } window = windowFlag; clipboard = UIPermissionClipboard.NoClipboard; }
public UIPermission(UIPermissionClipboard clipboardFlag) { if(clipboardFlag < UIPermissionClipboard.NoClipboard || clipboardFlag > UIPermissionClipboard.AllClipboard) { throw new ArgumentException(_("Arg_ClipboardFlag")); } window = UIPermissionWindow.NoWindows; clipboard = clipboardFlag; }
public UIPermission(UIPermissionWindow windowFlag) { if(windowFlag < UIPermissionWindow.NoWindows || windowFlag > UIPermissionWindow.AllWindows) { throw new ArgumentException(_("Arg_WindowFlag")); } window = windowFlag; clipboard = UIPermissionClipboard.NoClipboard; }
// Constructors. public UIPermission(PermissionState state) { if(state == PermissionState.None) { window = UIPermissionWindow.NoWindows; clipboard = UIPermissionClipboard.NoClipboard; } else if(state == PermissionState.Unrestricted) { window = UIPermissionWindow.AllWindows; clipboard = UIPermissionClipboard.AllClipboard; } else { throw new ArgumentException(_("Arg_PermissionState")); } }
/// <summary>Creates a permission that is the union of the permission and the specified permission.</summary> /// <returns>A new permission that represents the union of the current permission and the specified permission.</returns> /// <param name="target">A permission to combine with the current permission. It must be the same type as the current permission. </param> /// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not null and is not of the same type as the current permission. </exception> public override IPermission Union(IPermission target) { UIPermission uipermission = this.Cast(target); if (uipermission == null) { return(this.Copy()); } UIPermissionWindow uipermissionWindow = (this._window <= uipermission._window) ? uipermission._window : this._window; UIPermissionClipboard uipermissionClipboard = (this._clipboard <= uipermission._clipboard) ? uipermission._clipboard : this._clipboard; if (this.IsEmpty(uipermissionWindow, uipermissionClipboard)) { return(null); } return(new UIPermission(uipermissionWindow, uipermissionClipboard)); }
public override IPermission Intersect(IPermission target) { // Handle the easy cases first. if (target == null) { return(target); } else if (!(target is UIPermission)) { throw new ArgumentException(_("Arg_PermissionMismatch")); } else if (((UIPermission)target) .IsUnrestricted()) { return(Copy()); } else if (IsUnrestricted()) { return(target.Copy()); } // Get the minimum flag values. UIPermissionWindow w = ((UIPermission)target).window; if (((int)w) > ((int)window)) { w = window; } UIPermissionClipboard c = ((UIPermission)target).clipboard; if (((int)c) > ((int)clipboard)) { c = clipboard; } // Create a new object for the intersection. if (w == UIPermissionWindow.NoWindows && c == UIPermissionClipboard.NoClipboard) { return(null); } else { return(new UIPermission(w, c)); } }
// Constructors. public UIPermission(PermissionState state) { if (state == PermissionState.None) { window = UIPermissionWindow.NoWindows; clipboard = UIPermissionClipboard.NoClipboard; } else if (state == PermissionState.Unrestricted) { window = UIPermissionWindow.AllWindows; clipboard = UIPermissionClipboard.AllClipboard; } else { throw new ArgumentException(_("Arg_PermissionState")); } }
// Convert an XML value into a permissions value. public override void FromXml(SecurityElement esd) { String value; if (esd == null) { throw new ArgumentNullException("esd"); } if (esd.Attribute("version") != "1") { throw new ArgumentException(_("Arg_PermissionVersion")); } value = esd.Attribute("Unrestricted"); if (value != null && Boolean.Parse(value)) { window = UIPermissionWindow.NoWindows; clipboard = UIPermissionClipboard.NoClipboard; } else { value = esd.Attribute("Window"); if (value != null) { window = (UIPermissionWindow) Enum.Parse(typeof(UIPermissionWindow), value); } else { window = UIPermissionWindow.NoWindows; } value = esd.Attribute("Clipboard"); if (value != null) { clipboard = (UIPermissionClipboard) Enum.Parse(typeof(UIPermissionClipboard), value); } else { clipboard = UIPermissionClipboard.NoClipboard; } } }
public override IPermission Intersect(IPermission target) { if (target == null) { return(null); } if (!base.VerifyType(target)) { throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName })); } UIPermission permission = (UIPermission)target; UIPermissionWindow windowFlag = (this.m_windowFlag < permission.m_windowFlag) ? this.m_windowFlag : permission.m_windowFlag; UIPermissionClipboard clipboardFlag = (this.m_clipboardFlag < permission.m_clipboardFlag) ? this.m_clipboardFlag : permission.m_clipboardFlag; if ((windowFlag == UIPermissionWindow.NoWindows) && (clipboardFlag == UIPermissionClipboard.NoClipboard)) { return(null); } return(new UIPermission(windowFlag, clipboardFlag)); }
public override IPermission Union(IPermission target) { UIPermission uip = Cast(target); if (uip == null) { return(Copy()); } // there are not [Flags] so we can't use boolean operators UIPermissionWindow w = ((_window > uip._window) ? _window : uip._window); UIPermissionClipboard c = ((_clipboard > uip._clipboard) ? _clipboard : uip._clipboard); if (IsEmpty(w, c)) { return(null); } return(new UIPermission(w, c)); }
/// <summary>创建一个权限,该权限是当前权限和指定权限的并集。</summary> /// <returns>一个新权限,它表示当前权限与指定权限的并集。</returns> /// <param name="target">将与当前权限合并的权限。它必须与当前权限属于同一类型。</param> /// <exception cref="T:System.ArgumentException"> /// <paramref name="target" /> 参数不是 null,而且与当前权限不是同一类型。</exception> public override IPermission Union(IPermission target) { if (target == null) { return(this.Copy()); } if (!this.VerifyType(target)) { throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", (object)this.GetType().FullName)); } UIPermission uiPermission = (UIPermission)target; UIPermissionWindow windowFlag = this.m_windowFlag > uiPermission.m_windowFlag ? this.m_windowFlag : uiPermission.m_windowFlag; UIPermissionClipboard clipboardFlag = this.m_clipboardFlag > uiPermission.m_clipboardFlag ? this.m_clipboardFlag : uiPermission.m_clipboardFlag; if (windowFlag == UIPermissionWindow.NoWindows && clipboardFlag == UIPermissionClipboard.NoClipboard) { return((IPermission)null); } return((IPermission) new UIPermission(windowFlag, clipboardFlag)); }
public override void FromXml(SecurityElement esd) { CodeAccessPermission.ValidateElement(esd, this); if (XMLUtil.IsUnrestricted(esd)) { this.SetUnrestricted(true); } else { this.m_windowFlag = UIPermissionWindow.NoWindows; this.m_clipboardFlag = UIPermissionClipboard.NoClipboard; string str = esd.Attribute("Window"); if (str != null) { this.m_windowFlag = (UIPermissionWindow)Enum.Parse(typeof(UIPermissionWindow), str); } string str2 = esd.Attribute("Clipboard"); if (str2 != null) { this.m_clipboardFlag = (UIPermissionClipboard)Enum.Parse(typeof(UIPermissionClipboard), str2); } } }
public override void FromXml(SecurityElement esd) { CodeAccessPermission.ValidateElement(esd, this); if (XMLUtil.IsUnrestricted(esd)) { this.SetUnrestricted(true); } else { this.m_windowFlag = UIPermissionWindow.NoWindows; this.m_clipboardFlag = UIPermissionClipboard.NoClipboard; string str = esd.Attribute("Window"); if (str != null) { this.m_windowFlag = (UIPermissionWindow) Enum.Parse(typeof(UIPermissionWindow), str); } string str2 = esd.Attribute("Clipboard"); if (str2 != null) { this.m_clipboardFlag = (UIPermissionClipboard) Enum.Parse(typeof(UIPermissionClipboard), str2); } } }
/// <summary>Creates a permission that is the union of the permission and the specified permission.</summary> /// <param name="target">A permission to combine with the current permission. It must be the same type as the current permission. </param> /// <returns>A new permission that represents the union of the current permission and the specified permission.</returns> /// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not <see langword="null" /> and is not of the same type as the current permission. </exception> // Token: 0x06002660 RID: 9824 RVA: 0x0008AE18 File Offset: 0x00089018 public override IPermission Union(IPermission target) { if (target == null) { return(this.Copy()); } if (!base.VerifyType(target)) { throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName })); } UIPermission uipermission = (UIPermission)target; UIPermissionWindow uipermissionWindow = (this.m_windowFlag > uipermission.m_windowFlag) ? this.m_windowFlag : uipermission.m_windowFlag; UIPermissionClipboard uipermissionClipboard = (this.m_clipboardFlag > uipermission.m_clipboardFlag) ? this.m_clipboardFlag : uipermission.m_clipboardFlag; if (uipermissionWindow == UIPermissionWindow.NoWindows && uipermissionClipboard == UIPermissionClipboard.NoClipboard) { return(null); } return(new UIPermission(uipermissionWindow, uipermissionClipboard)); }
public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag) { }
public UIPermission(UIPermissionClipboard clipboardFlag) { }
public override void FromXml(SecurityElement esd) { CodeAccessPermission.ValidateElement( esd, this ); if (XMLUtil.IsUnrestricted( esd )) { SetUnrestricted( true ); return; } m_windowFlag = UIPermissionWindow.NoWindows; m_clipboardFlag = UIPermissionClipboard.NoClipboard; String window = esd.Attribute( "Window" ); if (window != null) m_windowFlag = (UIPermissionWindow)Enum.Parse( typeof( UIPermissionWindow ), window ); String clipboard = esd.Attribute( "Clipboard" ); if (clipboard != null) m_clipboardFlag = (UIPermissionClipboard)Enum.Parse( typeof( UIPermissionClipboard ), clipboard ); }
/// <summary>Initializes a new instance of the <see cref="T:System.Security.Permissions.UIPermission" /> class with the permissions for the Clipboard, and no access to windows.</summary><param name="clipboardFlag">One of the enumeration values. </param><exception cref="T:System.ArgumentException">The <paramref name="clipboardFlag" /> parameter is not a valid <see cref="T:System.Security.Permissions.UIPermissionClipboard" /> value. </exception> public UIPermission(UIPermissionClipboard clipboardFlag) { throw new NotImplementedException(); }
private static void VerifyClipboardFlag(UIPermissionClipboard flag) { if ((flag < UIPermissionClipboard.NoClipboard) || (flag > UIPermissionClipboard.AllClipboard)) { throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { (int) flag })); } }
// Convert an XML value into a permissions value. public override void FromXml(SecurityElement esd) { String value; if(esd == null) { throw new ArgumentNullException("esd"); } if(esd.Attribute("version") != "1") { throw new ArgumentException(_("Arg_PermissionVersion")); } value = esd.Attribute("Unrestricted"); if(value != null && Boolean.Parse(value)) { window = UIPermissionWindow.NoWindows; clipboard = UIPermissionClipboard.NoClipboard; } else { value = esd.Attribute("Window"); if(value != null) { window = (UIPermissionWindow) Enum.Parse(typeof(UIPermissionWindow), value); } else { window = UIPermissionWindow.NoWindows; } value = esd.Attribute("Clipboard"); if(value != null) { clipboard = (UIPermissionClipboard) Enum.Parse(typeof(UIPermissionClipboard), value); } else { clipboard = UIPermissionClipboard.NoClipboard; } } }
public UIPermission(UIPermissionClipboard clipboardFlag) { VerifyClipboardFlag(clipboardFlag); m_clipboardFlag = clipboardFlag; }
public UIPermission (UIPermissionClipboard clipboardFlag) { return default(UIPermission); }
public UIPermission (UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag) { return default(UIPermission); }
/// <summary>在具有使用剪贴板的权限,但没有对窗口的访问权限的情况下,初始化 <see cref="T:System.Security.Permissions.UIPermission" /> 类的新实例。</summary> /// <param name="clipboardFlag">枚举值之一。</param> /// <exception cref="T:System.ArgumentException"> /// <paramref name="clipboardFlag" /> 参数不是有效的 <see cref="T:System.Security.Permissions.UIPermissionClipboard" /> 值。</exception> public UIPermission(UIPermissionClipboard clipboardFlag) { UIPermission.VerifyClipboardFlag(clipboardFlag); this.m_clipboardFlag = clipboardFlag; }
private static void VerifyClipboardFlag(UIPermissionClipboard flag) { if (flag < UIPermissionClipboard.NoClipboard || flag > UIPermissionClipboard.AllClipboard) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)flag)); } }
public override void FromXml (SecurityElement esd) { // General validation in CodeAccessPermission CheckSecurityElement (esd, "esd", version, version); // Note: we do not (yet) care about the return value // as we only accept version 1 (min/max values) if (IsUnrestricted (esd)) { _window = UIPermissionWindow.AllWindows; _clipboard = UIPermissionClipboard.AllClipboard; } else { string w = esd.Attribute ("Window"); if (w == null) _window = UIPermissionWindow.NoWindows; else _window = (UIPermissionWindow) Enum.Parse (typeof (UIPermissionWindow), w); string c = esd.Attribute ("Clipboard"); if (c == null) _clipboard = UIPermissionClipboard.NoClipboard; else _clipboard = (UIPermissionClipboard) Enum.Parse (typeof (UIPermissionClipboard), c); } }
public UIPermission (UIPermissionClipboard clipboardFlag) { // reuse validation by the Clipboard property Clipboard = clipboardFlag; }
public UIPermission(UIPermissionClipboard clipboardFlag ) { VerifyClipboardFlag( clipboardFlag ); m_clipboardFlag = clipboardFlag; }
private void Reset() { m_windowFlag = UIPermissionWindow.NoWindows; m_clipboardFlag = UIPermissionClipboard.NoClipboard; }
private static void VerifyClipboardFlag(UIPermissionClipboard flag) { if (flag < UIPermissionClipboard.NoClipboard || flag > UIPermissionClipboard.AllClipboard) { throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)flag)); } Contract.EndContractBlock(); }
private void SetUnrestricted( bool unrestricted ) { if (unrestricted) { m_windowFlag = UIPermissionWindow.AllWindows; m_clipboardFlag = UIPermissionClipboard.AllClipboard; } }
// helpers private bool IsEmpty (UIPermissionWindow w, UIPermissionClipboard c) { return ((w == UIPermissionWindow.NoWindows) && (c == UIPermissionClipboard.NoClipboard)); }
public UIPermission (UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag) { // reuse validation by the Clipboard and Window properties Clipboard = clipboardFlag; Window = windowFlag; }