C# PermissionSet.FromXml方法代码示例

 public static void PermissionRequestEvidenceCallMethods()
 {
     PermissionSet ps = new PermissionSet(new PermissionState());
     PermissionRequestEvidence pre = new PermissionRequestEvidence(ps, ps, ps);
     PermissionRequestEvidence obj = pre.Copy();
     string str = ps.ToString();
     SecurityElement se = new SecurityElement("");
     ps.FromXml(se);
     se = ps.ToXml();
 }

 public static void PermissionSetCallMethods()
 {
     PermissionSet ps = new PermissionSet(new PermissionState());
     ps.Assert();
     bool containspermissions = ps.ContainsNonCodeAccessPermissions();
     PermissionSet ps2 = ps.Copy();
     ps.CopyTo(new int[1], 0);
     ps.Demand();
     ps.Equals(ps2);
     System.Collections.IEnumerator ie = ps.GetEnumerator();
     int hash = ps.GetHashCode();
     PermissionSet ps3 = ps.Intersect(ps2);
     bool isempty = ps.IsEmpty();
     bool issubsetof = ps.IsSubsetOf(ps2);
     bool isunrestricted = ps.IsUnrestricted();
     string s = ps.ToString();
     PermissionSet ps4 = ps.Union(ps2);
     SecurityElement se = new SecurityElement("");
     ps.FromXml(se);
     se = ps.ToXml();
 }

        private PermissionSet ParsePermissionSet(Parser parser)
        {
            SecurityElement e = parser.GetTopElement();
            PermissionSet permSet = new PermissionSet( PermissionState.None );
            permSet.FromXml( e );

            return permSet;
        }

		private PermissionSet CreateFromXml (string xml) 
		{
#if !NET_2_1
			SecurityParser sp = new SecurityParser ();
			try {
				sp.LoadXml (xml);
			}
			catch (Mono.Xml.SmallXmlParserException xe) {
				throw new XmlSyntaxException (xe.Line, xe.ToString ());
			}
			SecurityElement se = sp.ToXml ();

			string className = se.Attribute ("class");
			if (className == null)
				return null;

			PermissionState state = PermissionState.None;
			if (CodeAccessPermission.IsUnrestricted (se))
				state = PermissionState.Unrestricted;

			if (className.EndsWith ("NamedPermissionSet")) {
				NamedPermissionSet nps = new NamedPermissionSet (se.Attribute ("Name"), state);
				nps.FromXml (se);
				return (PermissionSet) nps;
			}
			else if (className.EndsWith ("PermissionSet")) {
				PermissionSet ps = new PermissionSet (state);
				ps.FromXml (se);
				return ps;
			}
#endif
			return null;
		}

        /// <include file='doc\PermissionAttributes.uex' path='docs/doc[@for="PermissionSetAttribute.CreatePermissionSet"]/*' />
        public PermissionSet CreatePermissionSet()
        {
            if (m_unrestricted)
            {
                return new PermissionSet( PermissionState.Unrestricted );
            }
            if (m_name != null)
            {
                return PolicyLevel.GetBuiltInSet( m_name );
            }
            else if (m_file != null || m_xml != null)
            {
                Parser parser = null;
                
                if (m_file != null)
                {
                    Encoding[] encodings = new Encoding[] { null, Encoding.UTF8, Encoding.ASCII, Encoding.Unicode };

                    bool success = false;
                    Exception exception = null;
                    FileStream f = new FileStream( m_file, FileMode.Open, FileAccess.Read );

                    for (int i = 0; !success && i < encodings.Length; ++i)
                    {

                        try
                        {
                            f.Position = 0;

                            StreamReader reader;
                            if (encodings[i] != null)
                                reader = new StreamReader( f, encodings[i] );
                            else
                                reader = new StreamReader( f );

                            parser = new Parser( reader );
                            success = true;
                        }
                        catch (Exception e1)
                        {
                            if (exception == null)
                                exception = e1;
                        }
                    }

                    if (!success && exception != null)
                        throw exception;
                }
                else
                {
                    // Since we have a unicode string, we have to copy the bytes
                    // into a byte array and create a data reader.
                   
                    parser = new Parser( m_xml.ToCharArray() );
                }
            
                SecurityElement e = parser.GetTopElement();

                // Note: we can just assume this is a regular permission set because
                // the name and description are not used in declarative security.

                PermissionSet permSet = new PermissionSet( PermissionState.None );

                permSet.FromXml( e );

                return permSet;
            }
            else
            {
                return new PermissionSet( PermissionState.None );
            }
        }

        /// <include file='doc\PermissionRequestEvidence.uex' path='docs/doc[@for="PermissionRequestEvidence.char1"]/*' />
        /// <internalonly/>
        int IBuiltInEvidence.InitFromBuffer( char[] buffer, int position )
        {
            int numPermSets = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position);
            position += 2;

            int tempLength;
            for (int i = 0; i < numPermSets; i++)
            {
                char psKind = buffer[position++];

                tempLength = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position);
                position += 2;

                String tempStr = new String(buffer, position, tempLength);
                position += tempLength;
                Parser p = new Parser( tempStr );

                PermissionSet psTemp = new PermissionSet();
                psTemp.FromXml(p.GetTopElement());

                switch(psKind)
                {
                    case idRequest:
                        m_strRequest = tempStr;
                        m_request = psTemp;
                        break;

                    case idOptional:
                        m_strOptional = tempStr;
                        m_optional = psTemp;
                        break;

                    case idDenied:
                        m_strDenied = tempStr;
                        m_denied = psTemp;
                        break;

                    default:
                        throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup"));
                }
            }

            return position;
        }