mscorlib-4.0-offline-doxygenated-documentation/html/_web_permission_8cs_source.html

 using System.Collections;
 using System.Runtime.Serialization;
 using System.Security;
 using System.Security.Permissions;
 using System.Text.RegularExpressions;

 namespace System.Net
 {
     [Serializable]
     public sealed class WebPermission : CodeAccessPermission, IUnrestrictedPermission
     {
         private bool m_noRestriction;

         [OptionalField]
         private bool m_UnrestrictedConnect;

         [OptionalField]
         private bool m_UnrestrictedAccept;

         private ArrayList m_connectList = new ArrayList();

         private ArrayList m_acceptList = new ArrayList();

         internal const string MatchAll = ".*";

         private static volatile Regex s_MatchAllRegex;

         internal static Regex MatchAllRegex
         {
             get
             {
                 if (s_MatchAllRegex == null)
                 {
                     s_MatchAllRegex = new Regex(".*");
                 }
                 return s_MatchAllRegex;
             }
         }

         public IEnumerator ConnectList
         {
             get
             {
                 if (m_UnrestrictedConnect)
                 {
                     return new Regex[1]
                     {
                         MatchAllRegex
                     }.GetEnumerator();
                 }
                 ArrayList arrayList = new ArrayList(m_connectList.Count);
                 for (int i = 0; i < m_connectList.Count; i++)
                 {
                     arrayList.Add((m_connectList[i] is DelayedRegex) ? ((DelayedRegex)m_connectList[i]).AsRegex : ((m_connectList[i] is Uri) ? ((Uri)m_connectList[i]).GetComponents(UriComponents.HttpRequestUrl, UriFormat.UriEscaped) : m_connectList[i]));
                 }
                 return arrayList.GetEnumerator();
             }
         }

         public IEnumerator AcceptList
         {
             get
             {
                 if (m_UnrestrictedAccept)
                 {
                     return new Regex[1]
                     {
                         MatchAllRegex
                     }.GetEnumerator();
                 }
                 ArrayList arrayList = new ArrayList(m_acceptList.Count);
                 for (int i = 0; i < m_acceptList.Count; i++)
                 {
                     arrayList.Add((m_acceptList[i] is DelayedRegex) ? ((DelayedRegex)m_acceptList[i]).AsRegex : ((m_acceptList[i] is Uri) ? ((Uri)m_acceptList[i]).GetComponents(UriComponents.HttpRequestUrl, UriFormat.UriEscaped) : m_acceptList[i]));
                 }
                 return arrayList.GetEnumerator();
             }
         }

         public WebPermission(PermissionState state)
         {
             m_noRestriction = (state == PermissionState.Unrestricted);
         }

         internal WebPermission(bool unrestricted)
         {
             m_noRestriction = unrestricted;
         }

         public WebPermission()
         {
         }

         internal WebPermission(NetworkAccess access)
         {
             m_UnrestrictedConnect = ((access & NetworkAccess.Connect) != (NetworkAccess)0);
             m_UnrestrictedAccept = ((access & NetworkAccess.Accept) != (NetworkAccess)0);
         }

         public WebPermission(NetworkAccess access, Regex uriRegex)
         {
             AddPermission(access, uriRegex);
         }

         public WebPermission(NetworkAccess access, string uriString)
         {
             AddPermission(access, uriString);
         }

         internal WebPermission(NetworkAccess access, Uri uri)
         {
             AddPermission(access, uri);
         }

         public void AddPermission(NetworkAccess access, string uriString)
         {
             if (uriString == null)
             {
                 throw new ArgumentNullException("uriString");
             }
             if (m_noRestriction)
             {
                 return;
             }
             if (Uri.TryCreate(uriString, UriKind.Absolute, out Uri result))
             {
                 AddPermission(access, result);
                 return;
             }
             ArrayList arrayList = new ArrayList();
             if ((access & NetworkAccess.Connect) != 0 && !m_UnrestrictedConnect)
             {
                 arrayList.Add(m_connectList);
             }
             if ((access & NetworkAccess.Accept) != 0 && !m_UnrestrictedAccept)
             {
                 arrayList.Add(m_acceptList);
             }
             foreach (ArrayList item in arrayList)
             {
                 bool flag = false;
                 foreach (object item2 in item)
                 {
                     string text = item2 as string;
                     if (text != null && string.Compare(text, uriString, StringComparison.OrdinalIgnoreCase) == 0)
                     {
                         flag = true;
                         break;
                     }
                 }
                 if (!flag)
                 {
                     item.Add(uriString);
                 }
             }
         }

         internal void AddPermission(NetworkAccess access, Uri uri)
         {
             if (uri == null)
             {
                 throw new ArgumentNullException("uri");
             }
             if (!m_noRestriction)
             {
                 ArrayList arrayList = new ArrayList();
                 if ((access & NetworkAccess.Connect) != 0 && !m_UnrestrictedConnect)
                 {
                     arrayList.Add(m_connectList);
                 }
                 if ((access & NetworkAccess.Accept) != 0 && !m_UnrestrictedAccept)
                 {
                     arrayList.Add(m_acceptList);
                 }
                 foreach (ArrayList item in arrayList)
                 {
                     bool flag = false;
                     foreach (object item2 in item)
                     {
                         if (item2 is Uri && uri.Equals(item2))
                         {
                             flag = true;
                             break;
                         }
                     }
                     if (!flag)
                     {
                         item.Add(uri);
                     }
                 }
             }
         }

         public void AddPermission(NetworkAccess access, Regex uriRegex)
         {
             if (uriRegex == null)
             {
                 throw new ArgumentNullException("uriRegex");
             }
             if (m_noRestriction)
             {
                 return;
             }
             if (uriRegex.ToString() == ".*")
             {
                 if (!m_UnrestrictedConnect && (access & NetworkAccess.Connect) != 0)
                 {
                     m_UnrestrictedConnect = true;
                     m_connectList.Clear();
                 }
                 if (!m_UnrestrictedAccept && (access & NetworkAccess.Accept) != 0)
                 {
                     m_UnrestrictedAccept = true;
                     m_acceptList.Clear();
                 }
             }
             else
             {
                 AddAsPattern(access, new DelayedRegex(uriRegex));
             }
         }

         internal void AddAsPattern(NetworkAccess access, DelayedRegex uriRegexPattern)
         {
             ArrayList arrayList = new ArrayList();
             if ((access & NetworkAccess.Connect) != 0 && !m_UnrestrictedConnect)
             {
                 arrayList.Add(m_connectList);
             }
             if ((access & NetworkAccess.Accept) != 0 && !m_UnrestrictedAccept)
             {
                 arrayList.Add(m_acceptList);
             }
             foreach (ArrayList item in arrayList)
             {
                 bool flag = false;
                 foreach (object item2 in item)
                 {
                     if (item2 is DelayedRegex && string.Compare(uriRegexPattern.ToString(), item2.ToString(), StringComparison.OrdinalIgnoreCase) == 0)
                     {
                         flag = true;
                         break;
                     }
                 }
                 if (!flag)
                 {
                     item.Add(uriRegexPattern);
                 }
             }
         }

         public bool IsUnrestricted()
         {
             return m_noRestriction;
         }

         public override IPermission Copy()
         {
             if (m_noRestriction)
             {
                 return new WebPermission(unrestricted: true);
             }
             WebPermission webPermission = new WebPermission((NetworkAccess)((m_UnrestrictedConnect ? 64 : 0) | (m_UnrestrictedAccept ? 128 : 0)));
             webPermission.m_acceptList = (ArrayList)m_acceptList.Clone();
             webPermission.m_connectList = (ArrayList)m_connectList.Clone();
             return webPermission;
         }

         public override bool IsSubsetOf(IPermission target)
         {
             if (target == null)
             {
                 if (!m_noRestriction && !m_UnrestrictedConnect && !m_UnrestrictedAccept && m_connectList.Count == 0)
                 {
                     return m_acceptList.Count == 0;
                 }
                 return false;
             }
             WebPermission webPermission = target as WebPermission;
             if (webPermission == null)
             {
                 throw new ArgumentException(SR.GetString("net_perm_target"), "target");
             }
             if (webPermission.m_noRestriction)
             {
                 return true;
             }
             if (m_noRestriction)
             {
                 return false;
             }
             DelayedRegex delayedRegex = null;
             if (!webPermission.m_UnrestrictedAccept)
             {
                 if (m_UnrestrictedAccept)
                 {
                     return false;
                 }
                 if (m_acceptList.Count != 0)
                 {
                     if (webPermission.m_acceptList.Count == 0)
                     {
                         return false;
                     }
                     foreach (object accept in m_acceptList)
                     {
                         delayedRegex = (accept as DelayedRegex);
                         if (delayedRegex != null)
                         {
                             if (!isSpecialSubsetCase(accept.ToString(), webPermission.m_acceptList))
                             {
                                 throw new NotSupportedException(SR.GetString("net_perm_both_regex"));
                             }
                         }
                         else if (!isMatchedURI(accept, webPermission.m_acceptList))
                         {
                             return false;
                         }
                     }
                 }
             }
             if (!webPermission.m_UnrestrictedConnect)
             {
                 if (m_UnrestrictedConnect)
                 {
                     return false;
                 }
                 if (m_connectList.Count != 0)
                 {
                     if (webPermission.m_connectList.Count == 0)
                     {
                         return false;
                     }
                     foreach (object connect in m_connectList)
                     {
                         delayedRegex = (connect as DelayedRegex);
                         if (delayedRegex != null)
                         {
                             if (!isSpecialSubsetCase(connect.ToString(), webPermission.m_connectList))
                             {
                                 throw new NotSupportedException(SR.GetString("net_perm_both_regex"));
                             }
                         }
                         else if (!isMatchedURI(connect, webPermission.m_connectList))
                         {
                             return false;
                         }
                     }
                 }
             }
             return true;
         }

         private static bool isSpecialSubsetCase(string regexToCheck, ArrayList permList)
         {
             foreach (object perm in permList)
             {
                 DelayedRegex delayedRegex = perm as DelayedRegex;
                 Uri uri;
                 if (delayedRegex != null)
                 {
                     if (string.Compare(regexToCheck, delayedRegex.ToString(), StringComparison.OrdinalIgnoreCase) == 0)
                     {
                         return true;
                     }
                 }
                 else if ((uri = (perm as Uri)) != null)
                 {
                     if (string.Compare(regexToCheck, Regex.Escape(uri.GetComponents(UriComponents.HttpRequestUrl, UriFormat.UriEscaped)), StringComparison.OrdinalIgnoreCase) == 0)
                     {
                         return true;
                     }
                 }
                 else if (string.Compare(regexToCheck, Regex.Escape(perm.ToString()), StringComparison.OrdinalIgnoreCase) == 0)
                 {
                     return true;
                 }
             }
             return false;
         }

         public override IPermission Union(IPermission target)
         {
             if (target == null)
             {
                 return Copy();
             }
             WebPermission webPermission = target as WebPermission;
             if (webPermission == null)
             {
                 throw new ArgumentException(SR.GetString("net_perm_target"), "target");
             }
             if (m_noRestriction || webPermission.m_noRestriction)
             {
                 return new WebPermission(unrestricted: true);
             }
             WebPermission webPermission2 = new WebPermission();
             if (m_UnrestrictedConnect || webPermission.m_UnrestrictedConnect)
             {
                 webPermission2.m_UnrestrictedConnect = true;
             }
             else
             {
                 webPermission2.m_connectList = (ArrayList)webPermission.m_connectList.Clone();
                 for (int i = 0; i < m_connectList.Count; i++)
                 {
                     DelayedRegex delayedRegex = m_connectList[i] as DelayedRegex;
                     if (delayedRegex == null)
                     {
                         if (m_connectList[i] is string)
                         {
                             webPermission2.AddPermission(NetworkAccess.Connect, (string)m_connectList[i]);
                         }
                         else
                         {
                             webPermission2.AddPermission(NetworkAccess.Connect, (Uri)m_connectList[i]);
                         }
                     }
                     else
                     {
                         webPermission2.AddAsPattern(NetworkAccess.Connect, delayedRegex);
                     }
                 }
             }
             if (m_UnrestrictedAccept || webPermission.m_UnrestrictedAccept)
             {
                 webPermission2.m_UnrestrictedAccept = true;
             }
             else
             {
                 webPermission2.m_acceptList = (ArrayList)webPermission.m_acceptList.Clone();
                 for (int j = 0; j < m_acceptList.Count; j++)
                 {
                     DelayedRegex delayedRegex2 = m_acceptList[j] as DelayedRegex;
                     if (delayedRegex2 == null)
                     {
                         if (m_acceptList[j] is string)
                         {
                             webPermission2.AddPermission(NetworkAccess.Accept, (string)m_acceptList[j]);
                         }
                         else
                         {
                             webPermission2.AddPermission(NetworkAccess.Accept, (Uri)m_acceptList[j]);
                         }
                     }
                     else
                     {
                         webPermission2.AddAsPattern(NetworkAccess.Accept, delayedRegex2);
                     }
                 }
             }
             return webPermission2;
         }

         public override IPermission Intersect(IPermission target)
         {
             if (target == null)
             {
                 return null;
             }
             WebPermission webPermission = target as WebPermission;
             if (webPermission == null)
             {
                 throw new ArgumentException(SR.GetString("net_perm_target"), "target");
             }
             if (m_noRestriction)
             {
                 return webPermission.Copy();
             }
             if (webPermission.m_noRestriction)
             {
                 return Copy();
             }
             WebPermission webPermission2 = new WebPermission();
             if (m_UnrestrictedConnect && webPermission.m_UnrestrictedConnect)
             {
                 webPermission2.m_UnrestrictedConnect = true;
             }
             else if (m_UnrestrictedConnect || webPermission.m_UnrestrictedConnect)
             {
                 webPermission2.m_connectList = (ArrayList)(m_UnrestrictedConnect ? webPermission : this).m_connectList.Clone();
             }
             else
             {
                 intersectList(m_connectList, webPermission.m_connectList, webPermission2.m_connectList);
             }
             if (m_UnrestrictedAccept && webPermission.m_UnrestrictedAccept)
             {
                 webPermission2.m_UnrestrictedAccept = true;
             }
             else if (m_UnrestrictedAccept || webPermission.m_UnrestrictedAccept)
             {
                 webPermission2.m_acceptList = (ArrayList)(m_UnrestrictedAccept ? webPermission : this).m_acceptList.Clone();
             }
             else
             {
                 intersectList(m_acceptList, webPermission.m_acceptList, webPermission2.m_acceptList);
             }
             if (!webPermission2.m_UnrestrictedConnect && !webPermission2.m_UnrestrictedAccept && webPermission2.m_connectList.Count == 0 && webPermission2.m_acceptList.Count == 0)
             {
                 return null;
             }
             return webPermission2;
         }

         public override void FromXml(SecurityElement securityElement)
         {
             if (securityElement == null)
             {
                 throw new ArgumentNullException("securityElement");
             }
             if (!securityElement.Tag.Equals("IPermission"))
             {
                 throw new ArgumentException(SR.GetString("net_not_ipermission"), "securityElement");
             }
             string text = securityElement.Attribute("class");
             if (text == null)
             {
                 throw new ArgumentException(SR.GetString("net_no_classname"), "securityElement");
             }
             if (text.IndexOf(GetType().FullName) < 0)
             {
                 throw new ArgumentException(SR.GetString("net_no_typename"), "securityElement");
             }
             string text2 = securityElement.Attribute("Unrestricted");
             m_connectList = new ArrayList();
             m_acceptList = new ArrayList();
             m_UnrestrictedAccept = (m_UnrestrictedConnect = false);
             if (text2 != null && string.Compare(text2, "true", StringComparison.OrdinalIgnoreCase) == 0)
             {
                 m_noRestriction = true;
                 return;
             }
             m_noRestriction = false;
             SecurityElement securityElement2 = securityElement.SearchForChildByTag("ConnectAccess");
             if (securityElement2 != null)
             {
                 foreach (SecurityElement child in securityElement2.Children)
                 {
                     if (child.Tag.Equals("URI"))
                     {
                         string text3;
                         try
                         {
                             text3 = child.Attribute("uri");
                         }
                         catch
                         {
                             text3 = null;
                         }
                         if (text3 == null)
                         {
                             throw new ArgumentException(SR.GetString("net_perm_invalid_val_in_element"), "ConnectAccess");
                         }
                         if (text3 == ".*")
                         {
                             m_UnrestrictedConnect = true;
                             m_connectList = new ArrayList();
                             break;
                         }
                         AddAsPattern(NetworkAccess.Connect, new DelayedRegex(text3));
                     }
                 }
             }
             securityElement2 = securityElement.SearchForChildByTag("AcceptAccess");
             if (securityElement2 != null)
             {
                 foreach (SecurityElement child2 in securityElement2.Children)
                 {
                     if (child2.Tag.Equals("URI"))
                     {
                         string text3;
                         try
                         {
                             text3 = child2.Attribute("uri");
                         }
                         catch
                         {
                             text3 = null;
                         }
                         if (text3 == null)
                         {
                             throw new ArgumentException(SR.GetString("net_perm_invalid_val_in_element"), "AcceptAccess");
                         }
                         if (text3 == ".*")
                         {
                             m_UnrestrictedAccept = true;
                             m_acceptList = new ArrayList();
                             break;
                         }
                         AddAsPattern(NetworkAccess.Accept, new DelayedRegex(text3));
                     }
                 }
             }
         }

         public override SecurityElement ToXml()
         {
             SecurityElement securityElement = new SecurityElement("IPermission");
             securityElement.AddAttribute("class", GetType().FullName + ", " + GetType().Module.Assembly.FullName.Replace('"', '\''));
             securityElement.AddAttribute("version", "1");
             if (!IsUnrestricted())
             {
                 string text = null;
                 if (m_UnrestrictedConnect || m_connectList.Count > 0)
                 {
                     SecurityElement securityElement2 = new SecurityElement("ConnectAccess");
                     if (m_UnrestrictedConnect)
                     {
                         SecurityElement securityElement3 = new SecurityElement("URI");
                         securityElement3.AddAttribute("uri", SecurityElement.Escape(".*"));
                         securityElement2.AddChild(securityElement3);
                     }
                     else
                     {
                         foreach (object connect in m_connectList)
                         {
                             Uri uri = connect as Uri;
                             text = ((!(uri != null)) ? connect.ToString() : Regex.Escape(uri.GetComponents(UriComponents.HttpRequestUrl, UriFormat.UriEscaped)));
                             if (connect is string)
                             {
                                 text = Regex.Escape(text);
                             }
                             SecurityElement securityElement4 = new SecurityElement("URI");
                             securityElement4.AddAttribute("uri", SecurityElement.Escape(text));
                             securityElement2.AddChild(securityElement4);
                         }
                     }
                     securityElement.AddChild(securityElement2);
                 }
                 if (m_UnrestrictedAccept || m_acceptList.Count > 0)
                 {
                     SecurityElement securityElement5 = new SecurityElement("AcceptAccess");
                     if (m_UnrestrictedAccept)
                     {
                         SecurityElement securityElement6 = new SecurityElement("URI");
                         securityElement6.AddAttribute("uri", SecurityElement.Escape(".*"));
                         securityElement5.AddChild(securityElement6);
                     }
                     else
                     {
                         foreach (object accept in m_acceptList)
                         {
                             Uri uri2 = accept as Uri;
                             text = ((!(uri2 != null)) ? accept.ToString() : Regex.Escape(uri2.GetComponents(UriComponents.HttpRequestUrl, UriFormat.UriEscaped)));
                             if (accept is string)
                             {
                                 text = Regex.Escape(text);
                             }
                             SecurityElement securityElement7 = new SecurityElement("URI");
                             securityElement7.AddAttribute("uri", SecurityElement.Escape(text));
                             securityElement5.AddChild(securityElement7);
                         }
                     }
                     securityElement.AddChild(securityElement5);
                 }
             }
             else
             {
                 securityElement.AddAttribute("Unrestricted", "true");
             }
             return securityElement;
         }

         private static bool isMatchedURI(object uriToCheck, ArrayList uriPatternList)
         {
             string text = uriToCheck as string;
             foreach (object uriPattern in uriPatternList)
             {
                 DelayedRegex delayedRegex = uriPattern as DelayedRegex;
                 if (delayedRegex == null)
                 {
                     if (uriToCheck.GetType() == uriPattern.GetType())
                     {
                         if (text != null && string.Compare(text, (string)uriPattern, StringComparison.OrdinalIgnoreCase) == 0)
                         {
                             return true;
                         }
                         if (text == null && uriToCheck.Equals(uriPattern))
                         {
                             return true;
                         }
                     }
                 }
                 else
                 {
                     string text2 = (text != null) ? text : ((Uri)uriToCheck).GetComponents(UriComponents.HttpRequestUrl, UriFormat.UriEscaped);
                     Match match = delayedRegex.AsRegex.Match(text2);
                     if (match != null && match.Index == 0 && match.Length == text2.Length)
                     {
                         return true;
                     }
                     if (text == null)
                     {
                         text2 = ((Uri)uriToCheck).GetComponents(UriComponents.HttpRequestUrl, UriFormat.SafeUnescaped);
                         match = delayedRegex.AsRegex.Match(text2);
                         if (match != null && match.Index == 0 && match.Length == text2.Length)
                         {
                             return true;
                         }
                     }
                 }
             }
             return false;
         }

         private static void intersectList(ArrayList A, ArrayList B, ArrayList result)
         {
             bool[] array = new bool[A.Count];
             bool[] array2 = new bool[B.Count];
             int num = 0;
             foreach (object item in A)
             {
                 int num2 = 0;
                 foreach (object item2 in B)
                 {
                     if (!array2[num2] && item.GetType() == item2.GetType())
                     {
                         if (item is Uri)
                         {
                             if (item.Equals(item2))
                             {
                                 result.Add(item);
                                 array[num] = (array2[num2] = true);
                                 break;
                             }
                         }
                         else if (string.Compare(item.ToString(), item2.ToString(), StringComparison.OrdinalIgnoreCase) == 0)
                         {
                             result.Add(item);
                             array[num] = (array2[num2] = true);
                             break;
                         }
                     }
                     num2++;
                 }
                 num++;
             }
             num = 0;
             foreach (object item3 in A)
             {
                 if (!array[num])
                 {
                     int num2 = 0;
                     foreach (object item4 in B)
                     {
                         if (!array2[num2])
                         {
                             bool isUri;
                             object obj = intersectPair(item3, item4, out isUri);
                             if (obj != null)
                             {
                                 bool flag = false;
                                 foreach (object item5 in result)
                                 {
                                     if (isUri == item5 is Uri && (isUri ? obj.Equals(item5) : (string.Compare(item5.ToString(), obj.ToString(), StringComparison.OrdinalIgnoreCase) == 0)))
                                     {
                                         flag = true;
                                         break;
                                     }
                                 }
                                 if (!flag)
                                 {
                                     result.Add(obj);
                                 }
                             }
                         }
                         num2++;
                     }
                 }
                 num++;
             }
         }

         private static object intersectPair(object L, object R, out bool isUri)
         {
             isUri = false;
             DelayedRegex delayedRegex = L as DelayedRegex;
             DelayedRegex delayedRegex2 = R as DelayedRegex;
             if (delayedRegex != null && delayedRegex2 != null)
             {
                 return new DelayedRegex("(?=(" + delayedRegex.ToString() + "))(" + delayedRegex2.ToString() + ")");
             }
             if (delayedRegex != null && delayedRegex2 == null)
             {
                 isUri = (R is Uri);
                 string text = isUri ? ((Uri)R).GetComponents(UriComponents.HttpRequestUrl, UriFormat.UriEscaped) : R.ToString();
                 Match match = delayedRegex.AsRegex.Match(text);
                 if (match != null && match.Index == 0 && match.Length == text.Length)
                 {
                     return R;
                 }
                 return null;
             }
             if (delayedRegex == null && delayedRegex2 != null)
             {
                 isUri = (L is Uri);
                 string text2 = isUri ? ((Uri)L).GetComponents(UriComponents.HttpRequestUrl, UriFormat.UriEscaped) : L.ToString();
                 Match match2 = delayedRegex2.AsRegex.Match(text2);
                 if (match2 != null && match2.Index == 0 && match2.Length == text2.Length)
                 {
                     return L;
                 }
                 return null;
             }
             isUri = (L is Uri);
             if (isUri)
             {
                 if (!L.Equals(R))
                 {
                     return null;
                 }
                 return L;
             }
             if (string.Compare(L.ToString(), R.ToString(), StringComparison.OrdinalIgnoreCase) != 0)
             {
                 return null;
             }
             return L;
         }
     }
 }
System.UriKind
UriKind
Defines the kinds of T:System.Uris for the M:System.Uri.IsWellFormedUriString(System....
Definition: UriKind.cs:5

System.Security
Definition: AllowPartiallyTrustedCallersAttribute.cs:3

System.Text
Definition: ASCIIEncoding.cs:4

System.Security.Permissions.IUnrestrictedPermission
Allows a permission to expose an unrestricted state.
Definition: IUnrestrictedPermission.cs:7

System.Net.WebPermission.FromXml
override void FromXml(SecurityElement securityElement)
Reconstructs a T:System.Net.WebPermission from an XML encoding.
Definition: WebPermission.cs:556

System.ArgumentNullException
The exception that is thrown when a null reference (Nothing in Visual Basic) is passed to a method th...
Definition: ArgumentNullException.cs:11

System.Net.WebPermission.Copy
override IPermission Copy()
Creates a copy of a T:System.Net.WebPermission.
Definition: WebPermission.cs:287

System.Text.RegularExpressions.Regex.ToString
override string ToString()
Returns the regular expression pattern that was passed into the Regex constructor.
Definition: Regex.cs:415

System.StringComparison
StringComparison
Specifies the culture, case, and sort rules to be used by certain overloads of the M:System....
Definition: StringComparison.cs:9

System.Net.NetworkAccess
NetworkAccess
Specifies network access permissions.
Definition: NetworkAccess.cs:5

System.ConsoleKey.R
The R key.

System.Runtime
Definition: AssemblyTargetedPatchBandAttribute.cs:1

System.Net.WebPermission.WebPermission
WebPermission(NetworkAccess access, Regex uriRegex)
Initializes a new instance of the T:System.Net.WebPermission class with the specified access rights f...
Definition: WebPermission.cs:111

System.Collections.ArrayList.Count
virtual int Count
Gets the number of elements actually contained in the T:System.Collections.ArrayList.
Definition: ArrayList.cs:2255

System
Definition: __Canon.cs:3

System.Security.SecurityElement.SearchForChildByTag
SecurityElement SearchForChildByTag(string tag)
Finds a child by its tag name.
Definition: SecurityElement.cs:757

System.Text.RegularExpressions
Definition: CachedCodeEntry.cs:3

System.Net.WebPermission.WebPermission
WebPermission(NetworkAccess access, string uriString)
Initializes a new instance of the T:System.Net.WebPermission class with the specified access rights f...
Definition: WebPermission.cs:121

System.Collections.ArrayList.Clear
virtual void Clear()
Removes all elements from the T:System.Collections.ArrayList.
Definition: ArrayList.cs:2461

System.Collections.ArrayList.Clone
virtual object Clone()
Creates a shallow copy of the T:System.Collections.ArrayList.
Definition: ArrayList.cs:2473

System.Security.SecurityElement.Tag
string Tag
Gets or sets the tag name of an XML element.
Definition: SecurityElement.cs:82

System.Uri.TryCreate
static bool TryCreate(string uriString, UriKind uriKind, out Uri result)
Creates a new T:System.Uri using the specified T:System.String instance and a T:System....
Definition: Uri.cs:4782

System.UriComponents
UriComponents
Specifies the parts of a T:System.Uri.
Definition: UriComponents.cs:6

System.Security.SecurityElement.Escape
static string Escape(string str)
Replaces invalid XML characters in a string with their valid XML equivalent.
Definition: SecurityElement.cs:548

System.Security.SecurityElement.AddChild
void AddChild(SecurityElement child)
Adds a child element to the XML element.
Definition: SecurityElement.cs:350

System.Net.WebPermission.WebPermission
WebPermission(PermissionState state)
Creates a new instance of the T:System.Net.WebPermission class that passes all demands or fails all d...
Definition: WebPermission.cs:87

System.ConsoleKey.L
The L key.

System.Net.WebPermission.WebPermission
WebPermission()
Creates a new instance of the T:System.Net.WebPermission class.
Definition: WebPermission.cs:98

System.Security.SecurityElement
Represents the XML object model for encoding security objects. This class cannot be inherited.
Definition: SecurityElement.cs:14

System.Text.RegularExpressions.Capture.Index
int Index
The position in the original string where the first character of the captured substring is found.
Definition: Capture.cs:18

System.Net.WebPermission
Controls rights to access HTTP Internet resources.
Definition: WebPermission.cs:11

System.Uri.Equals
unsafe override bool Equals(object comparand)
Compares two T:System.Uri instances for equality.
Definition: Uri.cs:1731

System.Security.CodeAccessPermission
Defines the underlying structure of all code access permissions.
Definition: CodeAccessPermission.cs:13

System.Runtime.Serialization
Definition: DeserializationEventHandler.cs:1

System.Uri.GetComponents
string GetComponents(UriComponents components, UriFormat format)
Gets the specified components of the current instance using the specified escaping for special charac...
Definition: Uri.cs:4874

System.Security.IPermission
Defines methods implemented by permission types.
Definition: IPermission.cs:7

System.Collections.ArrayList.Add
virtual int Add(object value)
Adds an object to the end of the T:System.Collections.ArrayList.
Definition: ArrayList.cs:2381

System.Net.WebPermission.IsSubsetOf
override bool IsSubsetOf(IPermission target)
Determines whether the current T:System.Net.WebPermission is a subset of the specified object.
Definition: WebPermission.cs:305

System.Text.RegularExpressions.Match
Represents the results from a single regular expression match.
Definition: Match.cs:8

System.Net.WebPermission.AddPermission
void AddPermission(NetworkAccess access, string uriString)
Adds the specified URI string with the specified access rights to the current T:System....
Definition: WebPermission.cs:136

System.ArgumentException
The exception that is thrown when one of the arguments provided to a method is not valid.
Definition: ArgumentException.cs:11

System.Text.RegularExpressions.Regex.Escape
static string Escape(string str)
Escapes a minimal set of characters (\, *, +, ?, |, {, [, (,), ^, $,., #, and white space) by replaci...
Definition: Regex.cs:386

System.AttributeTargets.Module
Attribute can be applied to a module.

System.Collections
Definition: ArrayList.cs:7

System.UriFormat
UriFormat
Controls how URI information is escaped.
Definition: UriFormat.cs:5

System.Net.WebPermission.ToXml
override SecurityElement ToXml()
Creates an XML encoding of a T:System.Net.WebPermission and its current state.
Definition: WebPermission.cs:649

System.Text.RegularExpressions.Capture.Length
int Length
Gets the length of the captured substring.
Definition: Capture.cs:30

System.Security.Permissions.PermissionState
PermissionState
Specifies whether a permission should have all or no access to resources at creation.
Definition: PermissionState.cs:8

System.ConsoleKey.B
The B key.

System.Net.WebPermission.ConnectList
IEnumerator?? ConnectList
This property returns an enumeration of a single connect permissions held by this T:System....
Definition: WebPermission.cs:44

System.Security.SecurityElement.AddAttribute
void AddAttribute(string name, string value)
Adds a name/value attribute to an XML element.
Definition: SecurityElement.cs:326

System.Reflection.TypeAttributes.Serializable
Specifies that the class can be serialized.

System.Net.WebPermission.Union
override IPermission Union(IPermission target)
Returns the logical union between two instances of the T:System.Net.WebPermission class.
Definition: WebPermission.cs:422

System.Security.SecurityElement.Children
ArrayList Children
Gets or sets the array of child elements of the XML element.
Definition: SecurityElement.cs:177

System.Collections.ArrayList.GetEnumerator
virtual IEnumerator GetEnumerator()
Returns an enumerator for the entire T:System.Collections.ArrayList.
Definition: ArrayList.cs:2615

System.NotSupportedException
The exception that is thrown when an invoked method is not supported, or when there is an attempt to ...
Definition: NotSupportedException.cs:10

System.Security.Permissions
Definition: BuiltInPermissionFlag.cs:1

System.Net.WebPermission.Intersect
override IPermission Intersect(IPermission target)
Returns the logical intersection of two T:System.Net.WebPermission instances.
Definition: WebPermission.cs:500

System.Uri
Provides an object representation of a uniform resource identifier (URI) and easy access to the parts...
Definition: Uri.cs:19

System.Text.RegularExpressions.Regex
Represents an immutable regular expression.To browse the .NET Framework source code for this type,...
Definition: Regex.cs:16

System.Collections.IEnumerator
Supports a simple iteration over a non-generic collection.
Definition: IEnumerator.cs:9

System.Net.WebPermission.AddPermission
void AddPermission(NetworkAccess access, Regex uriRegex)
Adds the specified URI with the specified access rights to the current T:System.Net....
Definition: WebPermission.cs:219

System.ConsoleKey.A
The A key.

System.Net.WebPermission.AcceptList
IEnumerator?? AcceptList
This property returns an enumeration of a single accept permissions held by this T:System....
Definition: WebPermission.cs:66

System.Net.WebPermission.IsUnrestricted
bool IsUnrestricted()
Checks the overall permission state of the T:System.Net.WebPermission.
Definition: WebPermission.cs:280

System.Net
Definition: _CERT_CHAIN_ELEMENT.cs:1

System.Collections.ArrayList
Implements the T:System.Collections.IList interface using an array whose size is dynamically increase...
Definition: ArrayList.cs:14