CodeAccessPermission.Union(IPermission) Método

Definición

Espacio de nombres:

System.Security

Ensamblado:

System.Security.Permissions.dll

Source:

CodeAccessPermission.cs

Cuando se invalida en una clase derivada, crea un permiso que es la unión del permiso actual y el permiso especificado.

public:
 virtual System::Security::IPermission ^ Union(System::Security::IPermission ^ other);

public virtual System.Security.IPermission Union(System.Security.IPermission other);

abstract member Union : System.Security.IPermission -> System.Security.IPermission
override this.Union : System.Security.IPermission -> System.Security.IPermission

Public Overridable Function Union (other As IPermission) As IPermission

Parámetros

other

IPermission

Permiso para combinar con el permiso actual. Debe ser del mismo tipo que el permiso actual.

Devoluciones

IPermission

Nuevo permiso que representa la unión del permiso actual y el permiso especificado.

Implementaciones

Union(IPermission)

Excepciones

NotSupportedException

El parámetro other no es un objeto null. Este método solo se admite en este nivel cuando se pasa null.

Ejemplos

En el ejemplo de código siguiente se muestra una invalidación del Union método . Este ejemplo de código es parte de un ejemplo más grande proporcionado para la clase CodeAccessPermission.

public:
   virtual IPermission^ Union( IPermission^ target ) override
   {
#if ( debug ) 
      Console::WriteLine( "************* Entering Union *********************" );
#endif 

      if ( target == nullptr )
      {
         return this;
      }

#if ( debug ) 
      Console::WriteLine( "This is = {0}", ((NameIdPermission)this).Name );
      Console::WriteLine( "Target is {0}", ((NameIdPermission)target).m_Name );
#endif 

      if (  !VerifyType( target ) )
      {
         throw gcnew ArgumentException( String::Format( "Argument_WrongType", this->GetType()->FullName ) );
      }

      NameIdPermission^ operand = dynamic_cast<NameIdPermission^>(target);

      if ( operand->IsSubsetOf( this ) )
      {
         return this->Copy();
      }
      else if ( this->IsSubsetOf( operand ) )
      {
         return operand->Copy();
      }
      else
      {
         return nullptr;
      }
   }

        public override IPermission Union(IPermission target)
        {
#if(debug)
            Console.WriteLine ("************* Entering Union *********************");
#endif
            if (target == null)
            {
                return this;
            }
#if(debug)
            Console.WriteLine ("This is = " + (( NameIdPermission)this).Name);
            Console.WriteLine ("Target is " + (( NameIdPermission)target).m_Name);
#endif
            if (!VerifyType(target))
            {
                throw new ArgumentException (String.Format ("Argument_WrongType", this.GetType ().FullName));
            }

             NameIdPermission operand = ( NameIdPermission)target;

            if (operand.IsSubsetOf (this)) return this.Copy ();
            else if (this.IsSubsetOf (operand)) return operand.Copy ();
            else
                return null;
        }

        Public Overrides Function Union(ByVal target As IPermission) As IPermission
#If (Debug) Then

            Console.WriteLine("************* Entering Union *********************")
#End If
            If target Is Nothing Then
                Return Me
            End If
#If (Debug) Then
            Console.WriteLine(("This is = " + CType(Me, NameIdPermission).Name))
            Console.WriteLine(("Target is " + CType(target, NameIdPermission).m_name))
#End If
            If Not VerifyType(target) Then
                Throw New ArgumentException(String.Format("Argument_WrongType", Me.GetType().FullName))
            End If

            Dim operand As NameIdPermission = CType(target, NameIdPermission)

            If operand.IsSubsetOf(Me) Then
                Return Me.Copy()
            ElseIf Me.IsSubsetOf(operand) Then
                Return operand.Copy()
            Else
                Return Nothing
            End If
        End Function 'Union

Comentarios

El resultado de una llamada a Union es un permiso que representa todas las operaciones representadas por el permiso actual y el permiso especificado. Cualquier demanda que pase cualquiera de los permisos pasa su unión.

Notas a los desarrolladores de herederos

Debe invalidar este método en una clase derivada. Debe devolver una copia del permiso si el valor del other parámetro es null.