diff --git a/tools/Tools.Common/Loaders/CmdletLoader.cs b/tools/Tools.Common/Loaders/CmdletLoader.cs
index 63edae07607b..39bfed4a1be2 100644
--- a/tools/Tools.Common/Loaders/CmdletLoader.cs
+++ b/tools/Tools.Common/Loaders/CmdletLoader.cs
@@ -74,149 +74,143 @@ public ModuleMetadata GetModuleMetadata(string assemblyPath)
                 ModuleMetadata.Cmdlets = results;
                 return ModuleMetadata;
             }
-            try
+
+            var assembly = Assembly.LoadFrom(assemblyPath);
+            foreach (var type in assembly.GetCmdletTypes())
             {
-                var assembly = Assembly.LoadFrom(assemblyPath);
-                foreach (var type in assembly.GetCmdletTypes())
+                var cmdlet = type.GetAttribute<CmdletAttribute>();
+                var outputs = type.GetAttributes<OutputTypeAttribute>();
+                var parameters = type.GetParameters();
+
+                var cmdletMetadata = new CmdletMetadata
+                {
+                    VerbName = cmdlet.VerbName,
+                    NounName = cmdlet.NounName,
+                    ConfirmImpact = cmdlet.ConfirmImpact,
+                    SupportsPaging = cmdlet.SupportsPaging,
+                    SupportsShouldProcess = cmdlet.SupportsShouldProcess,
+                    ClassName = type.FullName,
+                    DefaultParameterSetName = cmdlet.DefaultParameterSetName ?? "__AllParameterSets"
+                };
+
+                if (type.HasAttribute<AliasAttribute>())
+                {
+                    var aliases = type.GetAttributes<AliasAttribute>();
+                    cmdletMetadata.AliasList.AddRange(
+                        aliases.SelectMany(a => a.AliasNames));
+                }
+
+                foreach (var output in outputs)
                 {
-                    var cmdlet = type.GetAttribute<CmdletAttribute>();
-                    var outputs = type.GetAttributes<OutputTypeAttribute>();
-                    var parameters = type.GetParameters();
+                    foreach (var outputType in output.Type)
+                    {
+                        var outputMetadata = new OutputMetadata
+                        {
+                            Type = outputType.Type
+                        };
+                        outputMetadata.ParameterSets.AddRange(output.ParameterSetName);
+                        cmdletMetadata.OutputTypes.Add(outputMetadata);
+                    }
+                }
+
+                var globalParameters = new List<Parameter>();
+
+                foreach (var parameter in parameters)
+                {
+                    if (string.Equals(parameter.MemberInfo.Name, "Force", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType == typeof(SwitchParameter))
+                    {
+                        cmdletMetadata.HasForceSwitch = true;
+                    }
 
-                    var cmdletMetadata = new CmdletMetadata
+                    var parameterData = new Models.ParameterMetadata
                     {
-                        VerbName = cmdlet.VerbName,
-                        NounName = cmdlet.NounName,
-                        ConfirmImpact = cmdlet.ConfirmImpact,
-                        SupportsPaging = cmdlet.SupportsPaging,
-                        SupportsShouldProcess = cmdlet.SupportsShouldProcess,
-                        ClassName = type.FullName,
-                        DefaultParameterSetName = cmdlet.DefaultParameterSetName ?? "__AllParameterSets"
+                        Type = parameter.ParameterType,
+                        Name = parameter.MemberInfo.Name
                     };
 
-                    if (type.HasAttribute<AliasAttribute>())
+                    if (parameter.HasAttribute<AliasAttribute>())
                     {
-                        var aliases = type.GetAttributes<AliasAttribute>();
-                        cmdletMetadata.AliasList.AddRange(
+                        var aliases = parameter.GetAttributes<AliasAttribute>();
+                        parameterData.AliasList.AddRange(
                             aliases.SelectMany(a => a.AliasNames));
                     }
 
-                    foreach (var output in outputs)
+                    if (parameter.HasAttribute<ValidateSetAttribute>())
                     {
-                        foreach (var outputType in output.Type)
-                        {
-                            var outputMetadata = new OutputMetadata
-                            {
-                                Type = outputType.Type
-                            };
-                            outputMetadata.ParameterSets.AddRange(output.ParameterSetName);
-                            cmdletMetadata.OutputTypes.Add(outputMetadata);
-                        }
+                        var validateSet = parameter.GetAttribute<ValidateSetAttribute>();
+                        parameterData.ValidateSet.AddRange(validateSet.ValidValues);
                     }
 
-                    var globalParameters = new List<Parameter>();
-
-                    foreach (var parameter in parameters)
+                    if (parameter.HasAttribute<ValidateRangeAttribute>())
                     {
-                        if (string.Equals(parameter.MemberInfo.Name, "Force", StringComparison.OrdinalIgnoreCase) && parameter.ParameterType == typeof(SwitchParameter))
-                        {
-                            cmdletMetadata.HasForceSwitch = true;
-                        }
+                        var validateRange = parameter.GetAttribute<ValidateRangeAttribute>();
+                        parameterData.ValidateRangeMin = Convert.ToInt64(validateRange.MinRange);
+                        parameterData.ValidateRangeMax = Convert.ToInt64(validateRange.MaxRange);
+                    }
 
-                        var parameterData = new Models.ParameterMetadata
-                        {
-                            Type = parameter.ParameterType,
-                            Name = parameter.MemberInfo.Name
-                        };
+                    parameterData.ValidateNotNullOrEmpty = parameter.HasAttribute<ValidateNotNullOrEmptyAttribute>();
 
-                        if (parameter.HasAttribute<AliasAttribute>())
-                        {
-                            var aliases = parameter.GetAttributes<AliasAttribute>();
-                            parameterData.AliasList.AddRange(
-                                aliases.SelectMany(a => a.AliasNames));
-                        }
+                    cmdletMetadata.Parameters.Add(parameterData);
+
+                    foreach (var parameterSet in parameter.GetAttributes<ParameterAttribute>())
+                    {
+                        var parameterSetMetadata =
+                            cmdletMetadata.ParameterSets.FirstOrDefault(s => s.Name.Equals(parameterSet.ParameterSetName))
+                            ?? new Models.ParameterSetMetadata
+                            {
+                                Name = parameterSet.ParameterSetName ?? "__AllParameterSets"
+                            };
 
-                        if (parameter.HasAttribute<ValidateSetAttribute>())
+                        var param = new Parameter
                         {
-                            var validateSet = parameter.GetAttribute<ValidateSetAttribute>();
-                            parameterData.ValidateSet.AddRange(validateSet.ValidValues);
-                        }
+                            ParameterMetadata = parameterData,
+                            Mandatory = parameterSet.Mandatory,
+                            Position = parameterSet.Position,
+                            ValueFromPipeline = parameterSet.ValueFromPipeline,
+                            ValueFromPipelineByPropertyName = parameterSet.ValueFromPipelineByPropertyName
+                        };
 
-                        if (parameter.HasAttribute<ValidateRangeAttribute>())
+                        if (parameterSet.ParameterSetName.Equals("__AllParameterSets"))
                         {
-                            var validateRange = parameter.GetAttribute<ValidateRangeAttribute>();
-                            parameterData.ValidateRangeMin = Convert.ToInt64(validateRange.MinRange);
-                            parameterData.ValidateRangeMax = Convert.ToInt64(validateRange.MaxRange);
+                            globalParameters.Add(param);
                         }
 
-                        parameterData.ValidateNotNullOrEmpty = parameter.HasAttribute<ValidateNotNullOrEmptyAttribute>();
+                        parameterSetMetadata.Parameters.Add(param);
 
-                        cmdletMetadata.Parameters.Add(parameterData);
-
-                        foreach (var parameterSet in parameter.GetAttributes<ParameterAttribute>())
+                        if (parameterSetMetadata.Parameters.Count == 1)
                         {
-                            var parameterSetMetadata = 
-                                cmdletMetadata.ParameterSets.FirstOrDefault(s => s.Name.Equals(parameterSet.ParameterSetName))
-                                ?? new Models.ParameterSetMetadata
-                                {
-                                    Name = parameterSet.ParameterSetName ?? "__AllParameterSets"
-                                };
-
-                            var param = new Parameter
-                            {
-                                ParameterMetadata = parameterData,
-                                Mandatory = parameterSet.Mandatory,
-                                Position = parameterSet.Position,
-                                ValueFromPipeline = parameterSet.ValueFromPipeline,
-                                ValueFromPipelineByPropertyName = parameterSet.ValueFromPipelineByPropertyName
-                            };
-
-                            if (parameterSet.ParameterSetName.Equals("__AllParameterSets"))
-                            {
-                                globalParameters.Add(param);
-                            }
-
-                            parameterSetMetadata.Parameters.Add(param);
-
-                            if (parameterSetMetadata.Parameters.Count == 1)
-                            {
-                                cmdletMetadata.ParameterSets.Add(parameterSetMetadata);
-                            }
+                            cmdletMetadata.ParameterSets.Add(parameterSetMetadata);
                         }
                     }
+                }
 
-                    foreach (var parameterSet in cmdletMetadata.ParameterSets)
+                foreach (var parameterSet in cmdletMetadata.ParameterSets)
+                {
+                    if (parameterSet.Name.Equals("__AllParameterSets"))
                     {
-                        if (parameterSet.Name.Equals("__AllParameterSets"))
-                        {
-                            continue;
-                        }
-
-                        foreach (var parameter in globalParameters)
-                        {
-                            var param = parameterSet.Parameters.FirstOrDefault(p => p.ParameterMetadata.Name.Equals(parameter.ParameterMetadata.Name));
-                            if (param == null)
-                            {
-                                parameterSet.Parameters.Add(parameter);
-                            }
-                        }
+                        continue;
                     }
 
-                    if (!cmdletMetadata.ParameterSets.Any(p => p.Name.Equals(cmdletMetadata.DefaultParameterSetName, StringComparison.OrdinalIgnoreCase)))
+                    foreach (var parameter in globalParameters)
                     {
-                        var defaultSet = new Models.ParameterSetMetadata
+                        var param = parameterSet.Parameters.FirstOrDefault(p => p.ParameterMetadata.Name.Equals(parameter.ParameterMetadata.Name));
+                        if (param == null)
                         {
-                            Name = cmdletMetadata.DefaultParameterSetName
-                        };
-                        cmdletMetadata.ParameterSets.Add(defaultSet);
+                            parameterSet.Parameters.Add(parameter);
+                        }
                     }
+                }
 
-                    results.Add(cmdletMetadata);
+                if (!cmdletMetadata.ParameterSets.Any(p => p.Name.Equals(cmdletMetadata.DefaultParameterSetName, StringComparison.OrdinalIgnoreCase)))
+                {
+                    var defaultSet = new Models.ParameterSetMetadata
+                    {
+                        Name = cmdletMetadata.DefaultParameterSetName
+                    };
+                    cmdletMetadata.ParameterSets.Add(defaultSet);
                 }
-            }
-            catch (Exception ex)
-            {
-                throw;
+
+                results.Add(cmdletMetadata);
             }
 
             ModuleMetadata.Cmdlets = results;