IUnrestrictedPermissionとは? わかりやすく解説

IUnrestrictedPermission インターフェイス

アクセス許可無制限の状態を公開できるようにします。

名前空間: System.Security.Permissions
アセンブリ: mscorlib (mscorlib.dll 内)
構文構文

<ComVisibleAttribute(True)> _
Public Interface IUnrestrictedPermission
Dim instance As IUnrestrictedPermission
[ComVisibleAttribute(true)] 
public interface IUnrestrictedPermission
[ComVisibleAttribute(true)] 
public interface class IUnrestrictedPermission
/** @attribute ComVisibleAttribute(true) */ 
public interface IUnrestrictedPermission
ComVisibleAttribute(true) 
public interface IUnrestrictedPermission
解説解説

すべてのコード アクセス許可IUnrestrictedPermission実装する必要があります

使用例使用例

この例では、コード アクセス セキュリティ使用するアクセス許可クラス定義する方法示します必要なすべてのアクセス許可インターフェイス実装されています。

using System;
using System.Security;
using System.Security.Permissions;
using System.Reflection;

// Enumerated type for permission states.
[Serializable]
public enum SoundPermissionState 
{
    NoSound = 0,
    PlaySystemSounds = 1,
    PlayAnySound = 2
}

// Derive from CodeAccessPermission to gain implementations of the following
// sealed IStackWalk methods: Assert, Demand, Deny, and PermitOnly.
// Implement the following abstract IPermission methods: Copy, Intersect,
 and IsSubSetOf.
// Implementing the Union method of the IPermission class is optional.
// Implement the following abstract ISecurityEncodable methods: FromXml
 and ToXml.
// Making the class 'sealed' is optional.

public sealed class SoundPermission : CodeAccessPermission,
 IPermission, 
    IUnrestrictedPermission, ISecurityEncodable, ICloneable 
{
    private Boolean m_specifiedAsUnrestricted = false;
    private SoundPermissionState m_flags = SoundPermissionState.NoSound;

    // This constructor creates and initializes a permission with generic
 access.
    public SoundPermission(PermissionState state)
    {
        m_specifiedAsUnrestricted = (state == PermissionState.Unrestricted);
    }

    // This constructor creates and initializes a permission with specific
 access.        
    public SoundPermission(SoundPermissionState flags) 
    {
        if (!Enum.IsDefined(typeof(SoundPermissionState), flags))
            throw new ArgumentException
                ("flags value is not valid for the SoundPermissionState
 enuemrated type");
        m_specifiedAsUnrestricted = false;
        m_flags = flags;
    }

    // For debugging, return the state of this object as XML.
    public override String ToString() { return
 ToXml().ToString(); }

    // Private method to cast (if possible) an IPermission to the type.
    private SoundPermission VerifyTypeMatch(IPermission target)
 
    {
        if (GetType() != target.GetType())
            throw new ArgumentException(String.Format("target
 must be of the {0} type",
                GetType().FullName));
        return (SoundPermission) target;
    }

    // This is the Private Clone helper method. 
    private SoundPermission Clone(Boolean specifiedAsUnrestricted,
 SoundPermissionState flags) 
    {
        SoundPermission soundPerm = (SoundPermission) Clone();
        soundPerm.m_specifiedAsUnrestricted = specifiedAsUnrestricted;
        soundPerm.m_flags = specifiedAsUnrestricted ? SoundPermissionState.PlayAnySound
 : m_flags;
        return soundPerm;
    }

    #region IPermission Members
    // Return a new object that contains the intersection of 'this'
 and 'target'.
    public override IPermission Intersect(IPermission target)
 
    {
        // If 'target' is null, return null.
        if (target == null) return
 null;

        // Both objects must be the same type.
        SoundPermission soundPerm = VerifyTypeMatch(target);

        // If 'this' and 'target' are unrestricted, return a new unrestricted
 permission.
        if (m_specifiedAsUnrestricted && soundPerm.m_specifiedAsUnrestricted)
            return Clone(true, SoundPermissionState.PlayAnySound);

        // Calculate the intersected permissions. If there are none,
 return null.
        SoundPermissionState val = (SoundPermissionState)
            Math.Min((Int32) m_flags, (Int32) soundPerm.m_flags);
        if (val == 0) return null;

        // Return a new object with the intersected permission value.
        return Clone(false, val);
    }

    // Called by the Demand method: returns true if 'this' is a subset
 of 'target'.
    public override Boolean IsSubsetOf(IPermission target) 
    {
        // If 'target' is null and this permission allows nothing, return
 true.
        if (target == null) return
 m_flags == 0;

        // Both objects must be the same type.
        SoundPermission soundPerm = VerifyTypeMatch(target);

        // Return true if the permissions of 'this' is a subset of 'target'.
        return m_flags <= soundPerm.m_flags;
    }

    // Return a new object that matches 'this' object's permissions.
    public sealed override IPermission Copy() 
    {
        return (IPermission) Clone();
    }
    
    // Return a new object that contains the union of 'this' and 'target'.
    // Note: You do not have to implement this method. If you do not,
 the version
    // in CodeAccessPermission does this:
    //    1. If target is not null, a NotSupportedException is thrown.
    //    2. If target is null, then Copy is called and the new object
 is returned.
    public override IPermission Union(IPermission target) 
    {
        // If 'target' is null, then return a copy of 'this'.
        if (target == null) return
 Copy();

        // Both objects must be the same type.
        SoundPermission soundPerm = VerifyTypeMatch(target);

        // If 'this' or 'target' are unrestricted, return a new unrestricted
 permission.
        if (m_specifiedAsUnrestricted || soundPerm.m_specifiedAsUnrestricted)
            return Clone(true, SoundPermissionState.PlayAnySound);

        // Return a new object with the calculated, unioned permission
 value.
        return Clone(false, (SoundPermissionState)
            Math.Max((Int32) m_flags, (Int32) soundPerm.m_flags));
    }
    #endregion

    #region ISecurityEncodable Members
    // Populate the permission's fields from XML.
    public override void FromXml(SecurityElement
 e) 
    {
        m_specifiedAsUnrestricted = false;
        m_flags = 0;

        // If XML indicates an unrestricted permission, make this permission
 unrestricted.
        String s = (String) e.Attributes["Unrestricted"];
        if (s != null) 
        {
            m_specifiedAsUnrestricted = Convert.ToBoolean(s);
            if (m_specifiedAsUnrestricted)
                m_flags = SoundPermissionState.PlayAnySound;
        }

        // If XML indicates a restricted permission, parse the flags.
        if (!m_specifiedAsUnrestricted) 
        {
            s = (String) e.Attributes["Flags"];
            if (s != null) 
            {
                m_flags = (SoundPermissionState)
                Convert.ToInt32(Enum.Parse(typeof(SoundPermission), s, true));
            }
        }
    }

    // Produce XML from the permission's fields.
    public override SecurityElement ToXml() {
        // These first three lines create an element with the required
 format.
        SecurityElement e = new SecurityElement("IPermission");
        // Replace the double quotation marks () with single quotation
 marks ()
        // to remain XML compliant when the culture is not neutral.
        e.AddAttribute("class", GetType().AssemblyQualifiedName.Replace('\"',
 '\''));
        e.AddAttribute("version", "1");

        if (!m_specifiedAsUnrestricted)
            e.AddAttribute("Flags", Enum.Format(typeof(SoundPermission),
 m_flags, "G"));
        else
            e.AddAttribute("Unrestricted", "true");
        return e;
    }
    #endregion

    #region IUnrestrictedPermission Members
    // Returns true if permission is effectively unrestricted.
    public Boolean IsUnrestricted() 
    {
        // This means that the object is unrestricted at runtime.
        return m_flags == SoundPermissionState.PlayAnySound;
    }
    #endregion

    #region ICloneable Members

    // Return a copy of the permission.
    public Object Clone() { return MemberwiseClone();
 }

    #endregion
}
using namespace System;
using namespace System::Security;
using namespace System::Security::Permissions;
using namespace System::Reflection;

// Enumerated type for permission states.
[Serializable]
public enum class SoundPermissionState
{
    NoSound = 0,
    PlaySystemSounds = 1,
    PlayAnySound = 2
};

// Derive from CodeAccessPermission to gain implementations of the following
// sealed IStackWalk methods: Assert, Demand, Deny, and PermitOnly.
// Implement the following abstract IPermission methods: 
// Copy, Intersect, and IsSubSetOf.
// Implementing the Union method of the IPermission class is optional.
// Implement the following abstract ISecurityEncodable methods: 
// FromXml and ToXml.
// Making the class 'sealed' is optional.

public ref class SoundPermission sealed : public
 CodeAccessPermission, 
    public IPermission, public IUnrestrictedPermission,
 
    public ISecurityEncodable, public ICloneable
{
private:
    bool specifiedAsUnrestricted;
private:
    SoundPermissionState stateFlags;

    // This constructor creates and initializes 
    // a permission with generic access.
public:
    SoundPermission(PermissionState^ state)
    {
        specifiedAsUnrestricted = (state == PermissionState::Unrestricted);
    }

    // This constructor creates and initializes 
    // a permission with specific access.
public:
    SoundPermission(SoundPermissionState flags)
    {
        if (flags < SoundPermissionState::NoSound ||
            flags > SoundPermissionState::PlayAnySound)
        {
            throw gcnew ArgumentException("The value of \"flags\"
 is not" +
                " valid for the SoundPermissionState enumerated
 type");
        }
        stateFlags = flags;
    }

    // For debugging, return the state of this object as XML.
public:
    virtual String^ ToString() override
    {
        return ToXml()->ToString();
    }

    // Private method to cast (if possible) an IPermission to the type.
private:
    SoundPermission^ VerifyTypeMatch(IPermission^ target)
    {
        if (GetType() != target->GetType())
        {
            throw gcnew ArgumentException(String::Format(
                "The variable \"target\" must be of the {0} type"
,
                GetType()->FullName));
        }
        return (SoundPermission^) target;
    }

    // This is the Private Clone helper method.
private:
    SoundPermission^ Clone(bool specifiedAsUnrestricted, 
        SoundPermissionState flags)
    {
        SoundPermission^ soundPerm = (SoundPermission^) Clone();
        soundPerm->specifiedAsUnrestricted = specifiedAsUnrestricted;
        soundPerm->stateFlags = specifiedAsUnrestricted ? 
            SoundPermissionState::PlayAnySound : flags;
        return soundPerm;
    }

    #pragma region IPermission^ Members
    // Return a new object that contains the intersection 
    // of 'this' and 'target'.
public:
    virtual IPermission^ Intersect(IPermission^ target) override
    {
        // If 'target' is null, return null.
        if (target == nullptr)
        {
            return nullptr;
        }

        // Both objects must be the same type.
        SoundPermission^ soundPerm = VerifyTypeMatch(target);

        // If 'this' and 'target' are unrestricted, 
        // return a new unrestricted permission.
        if (specifiedAsUnrestricted && soundPerm->specifiedAsUnrestricted)
        {
            return Clone(true, SoundPermissionState::PlayAnySound);
        }

        // Calculate the intersected permissions. 
        // If there are none, return null.
        SoundPermissionState minimumPermission = (SoundPermissionState)
            Math::Min((int) stateFlags, (int)
 soundPerm->stateFlags);
        if ((int)minimumPermission == 0)
        {
            return nullptr;
        }

        // Return a new object with the intersected permission value.
        return Clone(false, minimumPermission);
    }

    // Called by the Demand method: returns true 
    // if 'this' is a subset of 'target'.
public:
    virtual bool IsSubsetOf(IPermission^ target) override
    {
        // If 'target' is null and this permission allows nothing, 
        // return true.
        if (target == nullptr)
        {
            return (int)stateFlags == 0;
        }

        // Both objects must be the same type.
        SoundPermission^ soundPerm = VerifyTypeMatch(target);

        // Return true if the permissions of 'this' 
        // is a subset of 'target'.
        return stateFlags <= soundPerm->stateFlags;
    }

    // Return a new object that matches 'this' object's permissions.
public:
    virtual IPermission^ Copy () override sealed
    {
        return (IPermission^) Clone();
    }

    // Return a new object that contains the union of 'this' and 'target'.
    // Note: You do not have to implement this method. 
    // If you do not, the version
    // in CodeAccessPermission does this:
    //    1. If target is not null, a NotSupportedException is thrown.
    //    2. If target is null, then Copy is called and 
    //       the new object is returned.
public:
    virtual IPermission^ Union(IPermission^ target) override
    {
        // If 'target' is null, then return a copy of 'this'.
        if (target == nullptr)
        {
            return Copy();
        }

        // Both objects must be the same type.
        SoundPermission^ soundPerm = VerifyTypeMatch(target);

        // If 'this' or 'target' are unrestricted, 
        // return a new unrestricted permission.
        if (specifiedAsUnrestricted || soundPerm->specifiedAsUnrestricted)
        {
            return Clone(true, SoundPermissionState::PlayAnySound);
        }

        // Return a new object with the calculated, unioned permission
 value.
        return Clone(false, (SoundPermissionState)
            Math::Max((int) stateFlags, (int)
 soundPerm->stateFlags));
    }
    #pragma endregion

    #pragma region ISecurityEncodable^ Members
    // Populate the permission's fields from XML.
public:
    virtual void FromXml(SecurityElement^ element) override
    {
        specifiedAsUnrestricted = false;
        stateFlags = (SoundPermissionState)0;

        // If XML indicates an unrestricted permission, 
        // make this permission unrestricted.
        String^ attributeString = 
            (String^) element->Attributes["Unrestricted"];
        if (attributeString != nullptr)
        {
            specifiedAsUnrestricted = Convert::ToBoolean(attributeString);
            if (specifiedAsUnrestricted)
            {
                stateFlags = SoundPermissionState::PlayAnySound;
            }
        }

        // If XML indicates a restricted permission, parse the flags.
        if (!specifiedAsUnrestricted)
        {
            attributeString = (String^) element->Attributes["Flags"];
            if (attributeString != nullptr)
            {
                stateFlags = (SoundPermissionState) Convert::ToInt32(
                    Enum::Parse(SoundPermissionState::typeid, 
                    attributeString, true));
            }
        }
    }

    // Produce XML from the permission's fields.
public:
    virtual SecurityElement^ ToXml() override
    {
        // These first three lines create an element with the required
 format.
        SecurityElement^ element = gcnew SecurityElement("IPermission");
        // Replace the double quotation marks () 
        // with single quotation marks ()
        // to remain XML compliant when the culture is not neutral.
        element->AddAttribute("class", 
            GetType()->AssemblyQualifiedName->Replace('\"', '\''));
        element->AddAttribute("version", "1");

        if (!specifiedAsUnrestricted)
        {
            element->AddAttribute("Flags", 
                Enum::Format(SoundPermissionState::typeid, stateFlags, "G"));
        }   
        else
        {
            element->AddAttribute("Unrestricted", "true");
        }
        return element;
    }
    #pragma endregion

    #pragma region IUnrestrictedPermission^ Members
    // Returns true if permission is effectively unrestricted.
public:
    virtual bool IsUnrestricted()
    {
        // This means that the object is unrestricted at runtime.
        return stateFlags == SoundPermissionState::PlayAnySound;
    }
    #pragma endregion

    #pragma region ICloneable^ Members

    // Return a copy of the permission.
public:
    virtual Object^ Clone()
    {
        return MemberwiseClone();
    }

    #pragma endregion
};
プラットフォームプラットフォーム
バージョン情報バージョン情報
参照参照

IUnrestrictedPermission メソッド


パブリック メソッドパブリック メソッド

  名前 説明
パブリック メソッド IsUnrestricted アクセス許可によって保護されているリソース無制限アクセスできるかどうかを示す値を返します
参照参照

関連項目

IUnrestrictedPermission インターフェイス
System.Security.Permissions 名前空間

その他の技術情報

アクセス許可
アクセス許可要求

IUnrestrictedPermission メンバ

アクセス許可無制限の状態を公開できるようにします。

IUnrestrictedPermission データ型公開されるメンバを以下の表に示します


パブリック メソッドパブリック メソッド
  名前 説明
パブリック メソッド IsUnrestricted アクセス許可によって保護されているリソース無制限アクセスできるかどうかを示す値を返します
参照参照

関連項目

IUnrestrictedPermission インターフェイス
System.Security.Permissions 名前空間

その他の技術情報

アクセス許可
アクセス許可要求



英和和英テキスト翻訳>> Weblio翻訳
英語⇒日本語日本語⇒英語
  

辞書ショートカット

すべての辞書の索引

「IUnrestrictedPermission」の関連用語

IUnrestrictedPermissionのお隣キーワード
検索ランキング

   

英語⇒日本語
日本語⇒英語
   



IUnrestrictedPermissionのページの著作権
Weblio 辞書 情報提供元は 参加元一覧 にて確認できます。

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2025 Microsoft.All rights reserved.

©2025 GRAS Group, Inc.RSS