C# RegistryPermission.Assert方法代码示例

 /// <summary> Gets a list of all available serial port names this controller provides. </summary>
 /// <returns> list of all available serial port names this controller provides. </returns>
 public List<string> GetPortNames() {
     RegistryKey baseKey = null;
     RegistryKey serialKey = null;
     var portNames = new List<string>();
     var regperm = new RegistryPermission(
         RegistryPermissionAccess.Read,
         @"HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\SERIALCOMM");
     regperm.Assert();
     try {
         baseKey = Registry.LocalMachine;
         serialKey = baseKey.OpenSubKey(@"HARDWARE\DEVICEMAP\SERIALCOMM", false);
         if (serialKey != null) {
             var deviceNames = serialKey.GetValueNames();
             portNames.AddRange(deviceNames.Select(devname => (string) serialKey.GetValue(devname)));
         }
     }
     finally {
         baseKey?.Dispose();
         serialKey?.Dispose();
         CodeAccessPermission.RevertAssert();
     }
     return portNames;
 }

        private static Uri GetRegistryPassportCertificationUrl()
        {
            // This Function Will return null, if the registry entry is missing

            // Acquire permissions to read the one key we care about from the registry
            RegistryPermission permission = new RegistryPermission(
                    RegistryPermissionAccess.Read,
                    System.Security.AccessControl.AccessControlActions.View,
                    _passportActivationRegistryFullKeyName);

            permission.Assert();

            try
            {
                RegistryKey key = Registry.LocalMachine.OpenSubKey(_passportActivationRegistryKeyName);
                if (key == null)
                {
                    return null;
                }
                else
                {
                    object keyValue = key.GetValue(null); // this should get the default value
                    string stringValue = keyValue as string;
                    if (stringValue != null)
                    {
                        return new Uri(stringValue);
                    }
                    else
                    {
                        return null;
                    }
                }
            }
            finally
            {
                RegistryPermission.RevertAssert();
            }
        }

        private static void DeleteRegistryEntry(string categoryName) {
            RegistryKey serviceKey = null;

            //SECREVIEW: Whoever is able to call this function, must already
            //                         have demmanded PerformanceCounterPermission
            //                         we can therefore assert the RegistryPermission.
            RegistryPermission registryPermission = new RegistryPermission(PermissionState.Unrestricted);
            registryPermission.Assert();
            try {
                serviceKey = Registry.LocalMachine.OpenSubKey(ServicePath, true);

                bool deleteCategoryKey = false;
                using (RegistryKey categoryKey = serviceKey.OpenSubKey(categoryName, true)) {
                    if (categoryKey != null) {
                        if (categoryKey.GetValueNames().Length == 0) {
                            deleteCategoryKey = true;
                        }
                        else {
                            categoryKey.DeleteSubKeyTree("Linkage");
                            categoryKey.DeleteSubKeyTree("Performance");
                        }
                    }
                }
                if (deleteCategoryKey)
                    serviceKey.DeleteSubKeyTree(categoryName);
                
            }
            finally {
                if (serviceKey != null)
                    serviceKey.Close();

                RegistryPermission.RevertAssert();
            }
        }

        private static void CreateRegistryEntry(string categoryName, PerformanceCounterCategoryType categoryType, CounterCreationDataCollection creationData, ref bool iniRegistered) {
            RegistryKey serviceParentKey = null;
            RegistryKey serviceKey = null;
            RegistryKey linkageKey = null;

            //SECREVIEW: Whoever is able to call this function, must already
            //                         have demmanded PerformanceCounterPermission
            //                         we can therefore assert the RegistryPermission.
            RegistryPermission registryPermission = new RegistryPermission(PermissionState.Unrestricted);
            registryPermission.Assert();
            try {
                serviceParentKey = Registry.LocalMachine.OpenSubKey(ServicePath, true);

                serviceKey = serviceParentKey.OpenSubKey(categoryName + "\\Performance", true);
                if (serviceKey == null)
                    serviceKey = serviceParentKey.CreateSubKey(categoryName + "\\Performance");

                serviceKey.SetValue("Open","OpenPerformanceData");
                serviceKey.SetValue("Collect", "CollectPerformanceData");
                serviceKey.SetValue("Close","ClosePerformanceData");
                serviceKey.SetValue("Library", DllName);
                serviceKey.SetValue("IsMultiInstance", (int) categoryType, RegistryValueKind.DWord);
                serviceKey.SetValue("CategoryOptions", 0x3, RegistryValueKind.DWord);

                string [] counters = new string[creationData.Count];
                string [] counterTypes = new string[creationData.Count];
                for (int i = 0; i < creationData.Count; i++) {
                    counters[i] = creationData[i].CounterName;
                    counterTypes[i] = ((int) creationData[i].CounterType).ToString(CultureInfo.InvariantCulture);
                }

                linkageKey = serviceParentKey.OpenSubKey(categoryName + "\\Linkage" , true);
                if (linkageKey == null)
                    linkageKey = serviceParentKey.CreateSubKey(categoryName + "\\Linkage" );

                linkageKey.SetValue("Export", new string[]{categoryName});

                serviceKey.SetValue("Counter Types", (object) counterTypes);
                serviceKey.SetValue("Counter Names", (object) counters);

                object firstID = serviceKey.GetValue("First Counter");
                if (firstID != null)
                    iniRegistered  = true;
                else
                    iniRegistered  = false;
            }
            finally {
                if (serviceKey != null)
                    serviceKey.Close();

                if (linkageKey != null)
                    linkageKey.Close();

                if (serviceParentKey != null)
                    serviceParentKey.Close();

                RegistryPermission.RevertAssert();
            }
        }

            // What if an app is locked back?  Why would we use this?
        internal static string GetLatestBuildDllDirectory(string machineName) {
            string dllDir = "";
            RegistryKey baseKey = null;
            RegistryKey complusReg = null;
            
            //This property is retrieved only when creationg a new category,
            //                          the calling code already demanded PerformanceCounterPermission.
            //                          Therefore the assert below is safe.
                                                
            //This property is retrieved only when creationg a new log,
            //                          the calling code already demanded EventLogPermission.
            //                          Therefore the assert below is safe.

            RegistryPermission registryPermission = new RegistryPermission(PermissionState.Unrestricted);
            registryPermission.Assert();

            try {
                if (machineName.Equals(".")) {
                    return GetLocalBuildDirectory();
                }
                else {
                    baseKey = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, machineName);
                }
                if (baseKey == null)
                    throw new InvalidOperationException(SR.GetString(SR.RegKeyMissingShort, "HKEY_LOCAL_MACHINE", machineName));

                complusReg = baseKey.OpenSubKey("SOFTWARE\\Microsoft\\.NETFramework");
                if (complusReg != null) {
                    string installRoot = (string)complusReg.GetValue("InstallRoot");
                    if (installRoot != null && installRoot != String.Empty) {
                        // the "policy" subkey contains a v{major}.{minor} subkey for each version installed.  There are also
                        // some extra subkeys like "standards" and "upgrades" we want to ignore.

                        // first we figure out what version we are...
                        string versionPrefix = "v" + Environment.Version.Major + "." + Environment.Version.Minor;
                        RegistryKey policyKey = complusReg.OpenSubKey("policy");

                        // This is the full version string of the install on the remote machine we want to use (for example "v2.0.50727")
                        string version = null;

                        if (policyKey != null) {
                            try {
                                
                                // First check to see if there is a version of the runtime with the same minor and major number:
                                RegistryKey bestKey = policyKey.OpenSubKey(versionPrefix);

                                if (bestKey != null) {
                                    try {
                                        version = versionPrefix + "." + GetLargestBuildNumberFromKey(bestKey);
                                    } finally {
                                        bestKey.Close();
                                    }
                                } else {
                                    // There isn't an exact match for our version, so we will look for the largest version
                                    // installed.
                                    string[] majorVersions = policyKey.GetSubKeyNames();
                                    int[] largestVersion = new int[] { -1, -1, -1 };
                                    for (int i = 0; i < majorVersions.Length; i++) {

                                        string majorVersion = majorVersions[i];

                                        // If this looks like a key of the form v{something}.{something}, we should see if it's a usable build.
                                        if (majorVersion.Length > 1 && majorVersion[0] == 'v' && majorVersion.Contains(".")) {
                                            int[] currentVersion = new int[] { -1, -1, -1 };

                                            string[] splitVersion = majorVersion.Substring(1).Split('.');

                                            if(splitVersion.Length != 2) {
                                                continue;
                                            }

                                            if (!Int32.TryParse(splitVersion[0], out currentVersion[0]) || !Int32.TryParse(splitVersion[1], out currentVersion[1])) {
                                                continue;
                                            }

                                            RegistryKey k = policyKey.OpenSubKey(majorVersion);
                                            if (k == null) {
                                                // We may be able to use another subkey
                                                continue;
                                            }
                                            try {
                                                currentVersion[2] = GetLargestBuildNumberFromKey(k);

                                                if (currentVersion[0] > largestVersion[0]
                                                    || ((currentVersion[0] == largestVersion[0]) && (currentVersion[1] > largestVersion[1]))) {
                                                    largestVersion = currentVersion;
                                                }
                                            } finally {
                                                k.Close();
                                            }
                                        }
                                    }

                                    version = "v" + largestVersion[0] + "." + largestVersion[1] + "." + largestVersion[2];
                                }
                            } finally {
                                policyKey.Close();
                            }

//.........这里部分代码省略.........

        private unsafe CategoryData GetCategoryData() {
            CategoryData data = (CategoryData) categoryDataTable[categoryName];
            
            if (data == null) {
                lock(categoryDataTable) {
                    data = (CategoryData) categoryDataTable[categoryName];
                    if (data == null) {
                        data = new CategoryData();
                        data.FileMappingName = DefaultFileMappingName;
                        data.MutexName = categoryName;

                        RegistryPermission registryPermission = new RegistryPermission(PermissionState.Unrestricted);
                        registryPermission.Assert();
                        RegistryKey categoryKey = null;
                        try {
                            categoryKey = Registry.LocalMachine.OpenSubKey(PerformanceCounterLib.ServicePath + "\\" + categoryName + "\\Performance");

                            // first read the options
                            Object optionsObject = categoryKey.GetValue("CategoryOptions");
                            if (optionsObject != null) {
                                int options = (int) optionsObject;
                                data.EnableReuse = (((PerformanceCounterCategoryOptions) options & PerformanceCounterCategoryOptions.EnableReuse) != 0);
                        
                                if (((PerformanceCounterCategoryOptions) options & PerformanceCounterCategoryOptions.UseUniqueSharedMemory) != 0) {
                                    data.UseUniqueSharedMemory = true;
                                    InitialOffset = 8;
                                    data.FileMappingName = DefaultFileMappingName + categoryName;
                                }
                            }

                            int fileMappingSize;
                            object fileMappingSizeObject = categoryKey.GetValue("FileMappingSize");
                            if (fileMappingSizeObject != null && data.UseUniqueSharedMemory) {
                                // we only use this reg value in the unique shared memory case. 
                                fileMappingSize = (int) fileMappingSizeObject;
                                if (fileMappingSize < MinCountersFileMappingSize)
                                    fileMappingSize = MinCountersFileMappingSize;
                                                        
                                if (fileMappingSize > MaxCountersFileMappingSize)
                                    fileMappingSize = MaxCountersFileMappingSize;
                            }
                            else {
                                fileMappingSize = GetFileMappingSizeFromConfig(); 
                                if (data.UseUniqueSharedMemory)
                                    fileMappingSize = fileMappingSize >> 2;  // if we have a custom filemapping, only make it 25% as large. 
                            }

                            // now read the counter names
                            object counterNamesObject = categoryKey.GetValue("Counter Names");
                            byte[] counterNamesBytes = counterNamesObject as byte[];
                            
                            if (counterNamesBytes != null) {
                                ArrayList names = new ArrayList();
                                fixed (byte* counterNamesPtr = counterNamesBytes) {
                                    int start = 0;
                                    for (int i=0; i<counterNamesBytes.Length-1; i+=2) {
                                        if (counterNamesBytes[i] == 0 && counterNamesBytes[i+1] == 0 && start != i) {
                                            string counter = new String((sbyte*)counterNamesPtr, start, i-start, Encoding.Unicode);
                                            names.Add(counter.ToLowerInvariant());
                                            start = i+2;
                                        }
                                    }
                                }
                                data.CounterNames = names;
                            }
                            else {
                                string[] counterNames = (string[]) counterNamesObject;
                                for (int i=0; i<counterNames.Length; i++) 
                                    counterNames[i] = counterNames[i].ToLowerInvariant();
                                data.CounterNames = new ArrayList(counterNames);
                            }

                            // figure out the shared memory name
                            if (SharedUtils.CurrentEnvironment == SharedUtils.W2kEnvironment) {
                                data.FileMappingName = "Global\\" +  data.FileMappingName;
                                data.MutexName = "Global\\" + categoryName;
                            }

                            data.FileMapping = new FileMapping(data.FileMappingName, fileMappingSize, InitialOffset);
                            categoryDataTable[categoryName] = data;
                        }
                        finally {
                            if (categoryKey != null)
                                categoryKey.Close();
                            RegistryPermission.RevertAssert();
                        }
                    }
                }
            }
            baseAddress = (long) data.FileMapping.FileViewAddress;

            if (data.UseUniqueSharedMemory)
                InitialOffset = 8;
                                    

            return data;
        }

        public static string[] GetPortNames() {
            if (Environment.OSVersion.Platform == PlatformID.Win32Windows)
                throw new PlatformNotSupportedException(SR.GetString(SR.NotSupportedOS));
            
            // Get all the registered serial device names
            RegistryPermission registryPermission = new RegistryPermission(PermissionState.Unrestricted);
            registryPermission.Assert();

            RegistryKey baseKey = null;
            RegistryKey serialKey = null;
            
            Hashtable portNames = new Hashtable(10);

            try {
                baseKey = Registry.LocalMachine;
                serialKey = baseKey.OpenSubKey(@"HARDWARE\DEVICEMAP\SERIALCOMM", true);

                if (serialKey != null) {

                    string[] devices = serialKey.GetValueNames();
                    for (int j=0; j<devices.Length; j++) {
                        portNames.Add(devices[j], null);   
                    }
                }
            }
            finally {
                if (baseKey != null) 
                    baseKey.Close();
                
                if (serialKey != null) 
                    serialKey.Close();
                
                RegistryPermission.RevertAssert();
            }
            
            // Get all the MS-DOS names on the local machine 
            //(sending null for lpctstrName gets all the names)
            int dataSize;
            char[] buffer = CallQueryDosDevice(null, out dataSize); 

            // From QueryDosDevice, we get back a long string where the names are delimited by \0 and the end
            // of the string is indicated by two \0s
            ArrayList names = new ArrayList();
            ArrayList deviceNames = new ArrayList();

            int i=0;
            while (i < dataSize) {
                // Walk through the buffer building a name until we hit the delimiter \0
                int start = i;
                while (buffer[i] != '\0') {
                    i++;
                }

                if (i != start) {
                    // We now have an MS-DOS name (the common name). We call QueryDosDevice again with
                    // this name to get the underlying system name mapped to the MS-DOS name. 
                    string currentName = (new String(buffer, start, i-start)).Trim();
                    int nameSize;
                    char[] nameBuffer = CallQueryDosDevice(currentName, out nameSize);

                    // If we got a system name, see if it's a serial port name. If it is, add the common name
                    // to our list
                    if (nameSize > 0) {
                        // internalName will include the trailing null chars as well as any additional
                        // names that may get returned.  This is ok, since we are only interested in the
                        // first name and we can use StartsWith. 
                        string internalName = new string(nameBuffer, 0, nameSize-2).Trim();
                        
                        if (internalName.StartsWith(SERIAL_NAME) || portNames.ContainsKey(internalName)) {
                            names.Add(currentName);
                            deviceNames.Add(internalName);
                        }
                    }
                }
                i++;
            }
            
            string[] namesArray = new String[names.Count];
            names.CopyTo(namesArray);

            string[] deviceNamesArray = new String[deviceNames.Count];
            deviceNames.CopyTo(deviceNamesArray);

            // sort the common names according to their actual device ordering
            Array.Sort(deviceNamesArray, namesArray, Comparer.DefaultInvariant);
            
            return namesArray;
        }

 internal static string GetLatestBuildDllDirectory(string machineName)
 {
     string result = "";
     RegistryKey registryKey = null;
     RegistryKey registryKey2 = null;
     RegistryPermission registryPermission = new RegistryPermission(PermissionState.Unrestricted);
     registryPermission.Assert();
     try
     {
         if (machineName.Equals("."))
         {
             return SharedUtils.GetLocalBuildDirectory();
         }
         registryKey = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, machineName);
         if (registryKey == null)
         {
             throw new InvalidOperationException("RegKeyMissingShort");
         }
         registryKey2 = registryKey.OpenSubKey("SOFTWARE\\Microsoft\\.NETFramework");
         if (registryKey2 != null)
         {
             string text = (string)registryKey2.GetValue("InstallRoot");
             if (text != null && text != string.Empty)
             {
                 string text2 = string.Concat(new object[]
                 {
                     "v",
                     Environment.Version.Major,
                     ".",
                     Environment.Version.Minor
                 });
                 RegistryKey registryKey3 = registryKey2.OpenSubKey("policy");
                 string text3 = null;
                 if (registryKey3 != null)
                 {
                     try
                     {
                         RegistryKey registryKey4 = registryKey3.OpenSubKey(text2);
                         if (registryKey4 != null)
                         {
                             try
                             {
                                 text3 = text2 + "." + SharedUtils.GetLargestBuildNumberFromKey(registryKey4);
                                 goto IL_29A;
                             }
                             finally
                             {
                                 registryKey4.Close();
                             }
                         }
                         string[] subKeyNames = registryKey3.GetSubKeyNames();
                         int[] array = new int[]
                         {
                             -1,
                             -1,
                             -1
                         };
                         for (int i = 0; i < subKeyNames.Length; i++)
                         {
                             string text4 = subKeyNames[i];
                             if (text4.Length > 1 && text4[0] == 'v' && text4.Contains("."))
                             {
                                 int[] array2 = new int[]
                                 {
                                     -1,
                                     -1,
                                     -1
                                 };
                                 string[] array3 = text4.Substring(1).Split(new char[]
                                 {
                                     '.'
                                 });
                                 if (array3.Length == 2 && int.TryParse(array3[0], out array2[0]) && int.TryParse(array3[1], out array2[1]))
                                 {
                                     RegistryKey registryKey5 = registryKey3.OpenSubKey(text4);
                                     if (registryKey5 != null)
                                     {
                                         try
                                         {
                                             array2[2] = SharedUtils.GetLargestBuildNumberFromKey(registryKey5);
                                             if (array2[0] > array[0] || (array2[0] == array[0] && array2[1] > array[1]))
                                             {
                                                 array = array2;
                                             }
                                         }
                                         finally
                                         {
                                             registryKey5.Close();
                                         }
                                     }
                                 }
                             }
                         }
                         text3 = string.Concat(new object[]
                         {
                             "v",
                             array[0],
                             ".",
                             array[1],
                             ".",
//.........这里部分代码省略.........

        private static void ReadAnimationSmoothingSetting() 
        { 
#if PRERELEASE
            // Acquire permissions to read the one key we care about from the registry 
            RegistryPermission permission = new RegistryPermission(
                RegistryPermissionAccess.Read,
                System.Security.AccessControl.AccessControlActions.View,
                @"HKEY_LOCAL_MACHINE\Software\Microsoft\Avalon.Graphics"); 

            permission.Assert(); 
 
            try
            { 
                RegistryKey key = Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\Avalon.Graphics");
                if (key != null)
                {
                    object keyValue = key.GetValue("AnimationSmoothing"); 

                    // The Regkey now turns off AnimationSmoothing 
                    s_animationSmoothing = !(keyValue is int && ((int)keyValue) == 0); 
                }
            } 
            finally
            {
                RegistryPermission.RevertAssert();
            } 
#endif
        } 

        static internal CultureInfo GetCultureInfoByIetfLanguageTag(string languageTag)
        {
            CultureInfo culture = null;

            RegistryPermission regPerm = new RegistryPermission(RegistryPermissionAccess.Read, RegistryKeys.HKLM_IetfLanguage);//BlessedAssert
            regPerm.Assert();//BlessedAssert
            try
            {
                culture = CultureInfo.GetCultureInfoByIetfLanguageTag(languageTag);
            }
            finally
            {
                 RegistryPermission.RevertAssert();
            }
            return culture;
        }

        internal static bool IsFeatureDisabled(KeyToRead key)
        {
            string regValue = null;
            bool fResult = false;

            switch (key)
            {
                case KeyToRead.WebBrowserDisable:
                    regValue = RegistryKeys.value_WebBrowserDisallow;
                    break;
                case KeyToRead.MediaAudioDisable:
                    regValue = RegistryKeys.value_MediaAudioDisallow;
                    break;
                case KeyToRead.MediaVideoDisable:
                    regValue = RegistryKeys.value_MediaVideoDisallow;
                    break;
                case KeyToRead.MediaImageDisable:
                    regValue = RegistryKeys.value_MediaImageDisallow;
                    break;
                case KeyToRead.MediaAudioOrVideoDisable:
                    regValue = RegistryKeys.value_MediaAudioDisallow;
                    break;
                case KeyToRead.ScriptInteropDisable:
                    regValue = RegistryKeys.value_ScriptInteropDisallow;
                    break;
                default:// throw exception for invalid key
                throw(new System.ArgumentException(key.ToString()));

            }

            RegistryKey featureKey;
            //Assert for read access to HKLM\Software\Microsoft\Windows\Avalon
            RegistryPermission regPerm = new RegistryPermission(RegistryPermissionAccess.Read,"HKEY_LOCAL_MACHINE\\"+RegistryKeys.WPF_Features);//BlessedAssert
            regPerm.Assert();//BlessedAssert
            try
            {
                object obj = null;
                bool keyValue = false;
                // open the key and read the value
                featureKey = Registry.LocalMachine.OpenSubKey(RegistryKeys.WPF_Features);
                if (featureKey != null)
                {
                    // If key exists and value is 1 return true else false
                    obj = featureKey.GetValue(regValue);
                    keyValue = obj is int && ((int)obj == 1);
                    if (keyValue)
                    {
                        fResult = true;
                    }

                    // special case for audio and video since they can be orred
                    // this is in the condition that audio is enabled since that is
                    // the path that MediaAudioVideoDisable defaults to
                    // This is purely to optimize perf on the number of calls to assert
                    // in the media or audio scenario.

                    if ((fResult == false) && (key == KeyToRead.MediaAudioOrVideoDisable))
                    {
                        regValue = RegistryKeys.value_MediaVideoDisallow;
                        // If key exists and value is 1 return true else false
                        obj = featureKey.GetValue(regValue);
                        keyValue = obj is int && ((int)obj == 1);
                        if (keyValue)
                        {
                            fResult = true;
                        }
                    }
                }
            }
            finally
            {
                RegistryPermission.RevertAssert();
            }
            return fResult;
        }

 internal void ClassicRegistration(Assembly asm)
 {
     RegistryPermission permission = new RegistryPermission(PermissionState.Unrestricted);
     permission.Demand();
     permission.Assert();
     try
     {
         new RegistrationServices().RegisterAssembly(asm, AssemblyRegistrationFlags.SetCodeBase);
     }
     catch (Exception exception)
     {
         if ((exception is NullReferenceException) || (exception is SEHException))
         {
             throw;
         }
         throw new RegistrationException(Resource.FormatString("Reg_AssemblyRegErr", asm), exception);
     }
 }