/// <summary>
 /// Checks to see if Registry access is available to the caller
 /// 
 /// </summary>
 /// 
 /// <returns/>
 public bool GetIsRegistryAvailable()
 {
   PermissionSet permissionSet = new PermissionSet(PermissionState.None);
   RegistryPermission registryPermission = new RegistryPermission(PermissionState.Unrestricted);
   permissionSet.AddPermission((IPermission) registryPermission);
   return permissionSet.IsSubsetOf(AppDomain.CurrentDomain.PermissionSet);
 }

 //Read Registry
 public string RegistryReadr(string subKey,string keyName)
 {
     try
     {
         RegistryPermission regeditPermission = new RegistryPermission(RegistryPermissionAccess.Read, System.IO.Path.Combine(Registry.CurrentUser.ToString(), System.IO.Path.Combine(ProcestaVariables.Variables.REGISTRY_PATH, subKey)));
         regeditPermission.Demand();
         RegistryKey regeditRead = Registry.CurrentUser;
         regeditRead = regeditRead.OpenSubKey(System.IO.Path.Combine(ProcestaVariables.Variables.REGISTRY_PATH, subKey));
         if (regeditRead != null)
         {
             if ((regeditRead.GetValue(keyName)).GetType().Equals(typeof(Int32)))
             {
                 return regeditRead.GetValue(keyName).ToString();
             }
             else
             {
                 return (string)regeditRead.GetValue(keyName);
             }
         }
         else
         {
             RegistryWriter(subKey,keyName,string.Empty,RegistryValueKind.String);
             RegistryReadr(subKey, keyName);
             return null;
         }
     }
     catch (Exception)
     {
         MessageBox.Show(ProcestaVariables.Variables.ERROR_MESSAGES[0,4], ProcestaVariables.Variables.ERROR_MESSAGES[0,0], MessageBoxButtons.OK, MessageBoxIcon.Error);
         return null;
     }
 }

            /// <summary>
            /// Call this function before creating the RegistryUtils class in order to make sure that
            /// you (the caller) will have permissions to access the class.
            /// </summary>
            /// <param name="subKey">
            /// The sub key to demand permissions for.
            /// </param>
            public static void DemandLocalMachineAccess(string subKey)
            {
                // Create permission objects for the registry keys we're about to use.
                RegistryPermission readPermissions = new RegistryPermission(RegistryPermissionAccess.Read, @"HKEY_LOCAL_MACHINE\" + subKey);

                // Now force this function to throw a SecurityException if we don't already have these permissions.
                readPermissions.Demand();
            }

 private void CheckSecurity()
 {
     //check registry permissions
     RegistryPermission regPerm;
     regPerm = new RegistryPermission(RegistryPermissionAccess.Write, "HKEY_CLASSES_ROOT\\" + MenuName);
     regPerm.AddPathList(RegistryPermissionAccess.Write, "HKEY_CLASSES_ROOT\\" + Command);
     regPerm.Demand();
 }

 public static RegistryKey OpenOrCreateCompanyKey(this RegistryKey source)
 {
     RegistryPermission f = new RegistryPermission(RegistryPermissionAccess.AllAccess, "HKEY_LOCAL_MACHINE\\SOFTWARE");
     RegistryKey keySoftware = source.OpenOrCreateKey("SOFTWARE");
     AssemblyCompanyAttribute companyAttribute = System.Reflection.Assembly.GetEntryAssembly().GetCustomAttributes(typeof(AssemblyCompanyAttribute)).FirstOrDefault() as AssemblyCompanyAttribute;
     RegistryKey keyCompany = keySoftware.OpenOrCreateKey(companyAttribute.Company);
     return keyCompany;
 }

            /// <summary>
            /// Call this function before creating the RegistryUtils class in order to make sure that
            /// you (the caller) will have permissions to access the class.
            /// </summary>
            /// <param name="subKey">
            /// The sub key to demand permissions for.
            /// </param>
            public static void DemandCurrentUserAccess(string subKey)
            {
                // Create permission objects for the registry keys we're about to use.
                RegistryPermission fullPermissions = new RegistryPermission(RegistryPermissionAccess.AllAccess, @"HKEY_CURRENT_USER\" + subKey);

                // Now force this function to throw a SecurityException if we don't already have these permissions.
                fullPermissions.Demand();
            }

        /// <summary>
        /// Creates a new WebTransform.
        /// </summary>
        public WebTransform()
        {
            //[IsolatedStorageFilePermissionAttribute(SecurityAction.Demand, Unrestricted=true)]
            FileIOPermission filePerm = new FileIOPermission(PermissionState.None);
            RegistryPermission regPerm = new RegistryPermission(PermissionState.None);

            filePerm.Demand();
            regPerm.Demand();
        }

		public void PermissionStateUnrestricted ()
		{
			RegistryPermission ep = new RegistryPermission (PermissionState.Unrestricted);
			Assert.IsNotNull (ep, "RegistryPermission(PermissionState.Unrestricted)");
			Assert.IsTrue (ep.IsUnrestricted (), "IsUnrestricted");
			RegistryPermission copy = (RegistryPermission)ep.Copy ();
			Assert.AreEqual (ep.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
			SecurityElement se = ep.ToXml ();
			Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "ToXml-Unrestricted");
		}

		public void PermissionStateUnrestricted ()
		{
			RegistryPermission ep = new RegistryPermission (PermissionState.Unrestricted);
			AssertNotNull ("RegistryPermission(PermissionState.Unrestricted)", ep);
			Assert ("IsUnrestricted", ep.IsUnrestricted ());
			RegistryPermission copy = (RegistryPermission)ep.Copy ();
			AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
			SecurityElement se = ep.ToXml ();
			AssertEquals ("ToXml-Unrestricted", "true", se.Attribute ("Unrestricted"));
		}

        /// <summary>
        /// Grava um par chave valor no registro do windows
        /// </summary>
        /// <param name="chave">chave usada para identificar o objeto</param>
        /// <param name="valor">valor a ser guardado</param>
        public static void GravaValor(string chave, string valor)
        {
            var perm1 = new RegistryPermission(RegistryPermissionAccess.Write, Key);


            if (perm1.CanWriteKey(Key))
            {
                GravaValor(Key, chave, valor);
            }
        }

            /// <summary>
            /// Call this function before creating the RegistryUtils class in order to make sure that
            /// you (the caller) will have permissions to access the class.
            /// </summary>
            public static void Demand()
            {
                // Create permission objects for the registry keys we're about to use.
                string fullRegistryPath = @"HKEY_CURRENT_USER\Software\Microsoft\" + ApplicationAcronym;
                RegistryPermission fullPermissions =
                    new RegistryPermission(RegistryPermissionAccess.AllAccess, fullRegistryPath);

                // Now force this function to throw a SecurityException if we don't already have these permissions.
                fullPermissions.Demand();
            }

 internal static PermissionSet _UnsafeGetAssertPermSet()
 {
     PermissionSet set = new PermissionSet(PermissionState.None);
     RegistryPermission perm = new RegistryPermission(PermissionState.Unrestricted);
     set.AddPermission(perm);
     EnvironmentPermission permission2 = new EnvironmentPermission(PermissionState.Unrestricted);
     set.AddPermission(permission2);
     SecurityPermission permission3 = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
     set.AddPermission(permission3);
     return set;
 }

		public void PermissionStateNone ()
		{
			RegistryPermission ep = new RegistryPermission (PermissionState.None);
			AssertNotNull ("RegistryPermission(PermissionState.None)", ep);
			Assert ("IsUnrestricted", !ep.IsUnrestricted ());
			RegistryPermission copy = (RegistryPermission)ep.Copy ();
			AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
			SecurityElement se = ep.ToXml ();
			Assert ("ToXml-class", se.Attribute ("class").StartsWith (className));
			AssertEquals ("ToXml-version", "1", se.Attribute ("version"));
		}

		public void PermissionStateNone ()
		{
			RegistryPermission ep = new RegistryPermission (PermissionState.None);
			Assert.IsNotNull (ep, "RegistryPermission(PermissionState.None)");
			Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
			RegistryPermission copy = (RegistryPermission)ep.Copy ();
			Assert.AreEqual (ep.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
			SecurityElement se = ep.ToXml ();
			Assert.IsTrue (se.Attribute ("class").StartsWith (className), "ToXml-class");
			Assert.AreEqual ("1", se.Attribute ("version"), "ToXml-version");
		}

 public static bool CanReadKey(this RegistryPermission reg, string key)
 {
     try
     {
         RegistryPermission r = new RegistryPermission(RegistryPermissionAccess.Read, key);
         r.Demand();
         return true;
     }
     catch (SecurityException)
     {
         return false;
     }
 }

 public static bool HavePermissionsOnKey(this RegistryPermission reg, RegistryPermissionAccess accessLevel, string key)
 {
     try
     {
         RegistryPermission r = new RegistryPermission(accessLevel, key);
         r.Demand();
         return true;
     }
     catch (SecurityException)
     {
         return false;
     }
 }

 protected bool HavePermissionsOnKey(RegistryPermissionAccess accessLevel, string key)
 {
     try
     {
         RegistryPermission r = new RegistryPermission(accessLevel, key);
         r.Demand();
         return true;
     }
     catch (SecurityException)
     {
         return false;
     }
 }

        /// <summary>
        /// Content Type
        /// </summary>
        /// <param name="filepath">File Path</param>
        /// <returns>Content Type</returns>
        public static string ContentType(string filepath)
        {
            if (string.IsNullOrWhiteSpace(filepath))
            {
                throw new ArgumentException("filepath");
            }
            else
            {
                var fi = new FileInfo(filepath);
                var dotExt = fi.Extension.ToUpperInvariant();

                if (string.IsNullOrWhiteSpace(dotExt))
                {
                    throw new InvalidOperationException(string.Format("Unknown extension: {0}", dotExt));
                }
                else if (types.ContainsKey(dotExt))
                {
                    return types[dotExt];
                }
                else
                {
                    var regPerm = new RegistryPermission(RegistryPermissionAccess.Read, "\\\\HKEY_CLASSES_ROOT");
                    using (var classesRoot = Registry.ClassesRoot)
                    {
                        using (var typeKey = classesRoot.OpenSubKey("MIME\\Database\\Content Type"))
                        {
                            foreach (var keyname in typeKey.GetSubKeyNames())
                            {
                                using (var curKey = classesRoot.OpenSubKey("MIME\\Database\\Content Type\\" + keyname))
                                {
                                    var extension = curKey.GetValue("Extension");
                                    if (null != extension && extension.ToString().ToUpperInvariant() == dotExt)
                                    {
                                        return keyname;
                                    }
                                }
                            }
                        }
                    }

                    return null;
                }
            }
        }

        internal static PermissionSet _UnsafeGetAssertPermSet() {
            // SEC_NOTE: All callers should already be guarded by EventLogPermission demand.
            PermissionSet permissionSet = new PermissionSet(PermissionState.None);

            // We need RegistryPermission 
            RegistryPermission registryPermission = new RegistryPermission(PermissionState.Unrestricted);
            permissionSet.AddPermission(registryPermission);

            // It is not enough to just assert RegistryPermission, for some regkeys
            // we need to assert EnvironmentPermission too
            EnvironmentPermission environmentPermission = new EnvironmentPermission(PermissionState.Unrestricted);
            permissionSet.AddPermission(environmentPermission);

            // For remote machine registry access UnmanagdCodePermission is required.
            SecurityPermission securityPermission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
            permissionSet.AddPermission(securityPermission);

            return permissionSet;
        }

        public static bool RunSecurityDemands()
        {
            FileIOPermission fPer = new FileIOPermission(PermissionState.None);
            fPer.AllLocalFiles = FileIOPermissionAccess.AllAccess;
            fPer.AllFiles = FileIOPermissionAccess.AllAccess;
            try
            {
                fPer.Demand();
            }
            catch (SecurityException s)
            {
                Common.DebugHelper.WriteLine("File IO Permission Error: {0}", s.Message);
                return false;
            }

            System.Security.Permissions.FileDialogPermission fdPer = new FileDialogPermission(FileDialogPermissionAccess.None);
            fdPer.Access = FileDialogPermissionAccess.OpenSave;
            try
            {
                fdPer.Demand();
            }
            catch (System.Security.SecurityException s)
            {
                Common.DebugHelper.WriteLine("File Dialog Persmission Error: {0}", s.Message);
                return false;
            }

            System.Security.Permissions.RegistryPermission rPer = new RegistryPermission(PermissionState.None);
            rPer.SetPathList(RegistryPermissionAccess.AllAccess, "HKEY_LOCAL_MACHINE");
            try
            {
                fPer.Demand();
            }
            catch (System.Security.SecurityException s)
            {
                Common.DebugHelper.WriteLine("Registry Access Permission Error: {0}", s.Message);
                return false;
            }

            return true;
        }