/// <summary>
/// Gets the dynamic parameters for the clear-item cmdlet.
/// </summary>
/// <param name="path">
/// The path to the item if it was specified on the command line.
/// </param>
/// <param name="context">
/// The context which the core command is running.
/// </param>
/// <returns>
/// An object that has properties and fields decorated with
/// parsing attributes similar to a cmdlet class.
/// </returns>
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="path"/> refers to a provider that could not be found.
/// </exception>
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="path"/> refers to a drive that could not be found.
/// </exception>
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="path"/> refers to does
/// not support this operation.
/// </exception>
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
internal object ClearItemDynamicParameters(string path, CmdletProviderContext context)
{
if (path == null)
{
return(null);
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
CmdletProviderContext newContext =
new CmdletProviderContext(context);
newContext.SetFilters(
new Collection <string>(),
new Collection <string>(),
null);
Collection <string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
path,
true,
newContext,
out provider,
out providerInstance);
if (providerPaths.Count > 0)
{
// Get the dynamic parameters for the first resolved path
return(ClearItemDynamicParameters(providerInstance, providerPaths[0], newContext));
}
return(null);
}
/// <summary>
/// Gets the dynamic parameters for the get-content cmdlet.
/// </summary>
/// <param name="path">
/// The path to the item if it was specified on the command line.
/// </param>
/// <param name="context">
/// The context which the core command is running.
/// </param>
/// <returns>
/// An object that has properties and fields decorated with
/// parsing attributes similar to a cmdlet class.
/// </returns>
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="path"/> refers to a provider that could not be found.
/// </exception>
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="path"/> refers to a drive that could not be found.
/// </exception>
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="path"/> refers to does
/// not support this operation.
/// </exception>
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
internal object GetContentReaderDynamicParameters(
string path,
CmdletProviderContext context)
{
if (path == null)
{
return(null);
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
CmdletProviderContext newContext =
new CmdletProviderContext(context);
newContext.SetFilters(
new Collection <string>(),
new Collection <string>(),
null);
Collection <string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
path,
true,
newContext,
out provider,
out providerInstance);
return(GetContentReaderDynamicParameters(providerInstance, path, newContext));
}
internal void CopyProperty(string[] sourcePaths, string sourceProperty, string destinationPath, string destinationProperty, CmdletProviderContext context)
{
if (sourcePaths == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
if (sourceProperty == null)
{
throw PSTraceSource.NewArgumentNullException("sourceProperty");
}
if (destinationPath == null)
{
throw PSTraceSource.NewArgumentNullException("destinationPath");
}
if (destinationProperty == null)
{
throw PSTraceSource.NewArgumentNullException("destinationProperty");
}
foreach (string str in sourcePaths)
{
if (str == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
ProviderInfo info = null;
CmdletProvider providerInstance = null;
Collection<string> collection = this.Globber.GetGlobbedProviderPathsFromMonadPath(str, false, context, out info, out providerInstance);
if (collection.Count > 0)
{
Collection<string> include = context.Include;
Collection<string> exclude = context.Exclude;
string filter = context.Filter;
context.SetFilters(new Collection<string>(), new Collection<string>(), null);
Collection<string> collection4 = this.Globber.GetGlobbedProviderPathsFromMonadPath(destinationPath, false, context, out info, out providerInstance);
context.SetFilters(include, exclude, filter);
foreach (string str3 in collection)
{
foreach (string str4 in collection4)
{
this.CopyProperty(providerInstance, str3, sourceProperty, str4, destinationProperty, context);
}
}
}
}
}
internal object CopyItemDynamicParameters(string path, string destination, bool recurse, CmdletProviderContext context)
{
if (path != null)
{
ProviderInfo info = null;
CmdletProvider providerInstance = null;
CmdletProviderContext context2 = new CmdletProviderContext(context);
context2.SetFilters(new Collection<string>(), new Collection<string>(), null);
Collection<string> collection = this.Globber.GetGlobbedProviderPathsFromMonadPath(path, true, context2, out info, out providerInstance);
if (collection.Count > 0)
{
return this.CopyItemDynamicParameters(providerInstance, collection[0], destination, recurse, context2);
}
}
return null;
}
internal object SetPropertyDynamicParameters(string path, PSObject propertyValue, CmdletProviderContext context)
{
if (path != null)
{
ProviderInfo info = null;
CmdletProvider providerInstance = null;
CmdletProviderContext context2 = new CmdletProviderContext(context);
context2.SetFilters(new Collection<string>(), new Collection<string>(), null);
Collection<string> collection = this.Globber.GetGlobbedProviderPathsFromMonadPath(path, true, context2, out info, out providerInstance);
if (collection.Count > 0)
{
return this.SetPropertyDynamicParameters(providerInstance, collection[0], propertyValue, context2);
}
}
return null;
}
internal void MoveProperty(string[] sourcePaths, string sourceProperty, string destinationPath, string destinationProperty, CmdletProviderContext context)
{
if (sourcePaths == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
if (sourceProperty == null)
{
throw PSTraceSource.NewArgumentNullException("sourceProperty");
}
if (destinationPath == null)
{
throw PSTraceSource.NewArgumentNullException("destinationPath");
}
if (destinationProperty == null)
{
throw PSTraceSource.NewArgumentNullException("destinationProperty");
}
ProviderInfo info = null;
CmdletProvider providerInstance = null;
CmdletProviderContext context2 = new CmdletProviderContext(context);
context2.SetFilters(new Collection<string>(), new Collection<string>(), null);
Collection<string> targetObject = this.Globber.GetGlobbedProviderPathsFromMonadPath(destinationPath, false, context2, out info, out providerInstance);
if (targetObject.Count > 1)
{
ArgumentException exception = PSTraceSource.NewArgumentException("destinationPath", "SessionStateStrings", "MovePropertyDestinationResolveToSingle", new object[0]);
context.WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.InvalidArgument, targetObject));
}
else
{
foreach (string str in sourcePaths)
{
if (str == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
foreach (string str2 in this.Globber.GetGlobbedProviderPathsFromMonadPath(str, false, context, out info, out providerInstance))
{
this.MoveProperty(providerInstance, str2, sourceProperty, targetObject[0], destinationProperty, context);
}
}
}
}
internal object ItemExistsDynamicParameters(string path, CmdletProviderContext context)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
ProviderInfo info = null;
CmdletProvider providerInstance = null;
CmdletProviderContext context2 = new CmdletProviderContext(context);
context2.SetFilters(new Collection<string>(), new Collection<string>(), null);
Collection<string> collection = this.Globber.GetGlobbedProviderPathsFromMonadPath(path, true, context2, out info, out providerInstance);
if (collection.Count > 0)
{
return this.ItemExistsDynamicParameters(providerInstance, collection[0], context2);
}
return null;
}
} // GetChildNames
/// <summary>
/// Gets names of the children of the specified path.
/// </summary>
///
/// <param name="path">
/// The path to the item from which to retrieve the child names.
/// </param>
///
/// <param name="returnContainers">
/// Determines if all containers should be returned or only those containers that match the
/// filter(s).
/// </param>
///
/// <param name="recurse">
/// If true, gets all the relative paths of all the children
/// in all the sub-containers of the specified
/// container. If false, only gets the immediate child names of the specified
/// container.
/// </param>
///
/// <param name="depth">
/// Limits the depth of recursion; uint.MaxValue performs full recursion.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <returns>
/// Nothing is returned, but all names should be written to the context object.
/// </returns>
///
/// <remarks>
/// The child names are the leaf portion of the path. Example, for the file system
/// the name for the path c:\windows\system32\foo.dll would be foo.dll or for
/// the directory c:\windows\system32 would be system32. For Active Directory the
/// child names would be RDN values of the child objects of the container.
/// </remarks>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="path"/> or <paramref name="propertyToClear"/> is null.
/// </exception>
///
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="path"/> refers to a provider that could not be found.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="path"/> refers to a drive that could not be found.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="path"/> refers to does
/// not support this operation.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
///
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
///
internal void GetChildNames(
string path,
ReturnContainers returnContainers,
bool recurse,
uint depth,
CmdletProviderContext context)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
// Construct the include filter
Collection<WildcardPattern> includeMatcher =
SessionStateUtilities.CreateWildcardsFromStrings(
context.Include,
WildcardOptions.IgnoreCase);
// Construct the exclude filter
Collection<WildcardPattern> excludeMatcher =
SessionStateUtilities.CreateWildcardsFromStrings(
context.Exclude,
WildcardOptions.IgnoreCase);
if (LocationGlobber.ShouldPerformGlobbing(path, context))
{
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
// We don't want to process include/exclude filters
// when globbing the targets of the operation, so
// copy the context without the filters.
CmdletProviderContext resolvePathContext =
new CmdletProviderContext(context);
resolvePathContext.SetFilters(
new Collection<string>(),
new Collection<string>(),
null);
// Resolve the path
Collection<string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
path,
false,
resolvePathContext,
out provider,
out providerInstance);
if (resolvePathContext.Drive != null)
{
context.Drive = resolvePathContext.Drive;
}
bool pathContainsGlobCharacters = LocationGlobber.StringContainsGlobCharacters(path);
foreach (string providerPath in providerPaths)
{
// Making sure to obey the StopProcessing.
if (context.Stopping)
{
return;
}
if ((!pathContainsGlobCharacters || recurse) && IsItemContainer(providerInstance, providerPath, context))
{
// Since the path contained glob characters or we are recursing and the
// path is a container, do the name enumeration manually
DoGetChildNamesManually(
providerInstance,
providerPath,
String.Empty,
returnContainers,
includeMatcher,
excludeMatcher,
context,
recurse,
depth);
}
else
{
// Since the original path did not contain glob characters,
// if the provider is a NavigationCmdletProvider, write
// out the child name, else write out the name as it
// was resolved.
if (providerInstance is NavigationCmdletProvider)
{
string childName =
GetChildName(
providerInstance,
providerPath,
context, false);
bool isIncludeMatch =
SessionStateUtilities.MatchesAnyWildcardPattern(
childName,
includeMatcher,
true);
bool isExcludeMatch =
SessionStateUtilities.MatchesAnyWildcardPattern(
childName,
excludeMatcher,
false);
if (isIncludeMatch && !isExcludeMatch)
{
context.WriteObject(childName);
}
}
else
{
context.WriteObject(providerPath);
}
}
}
}
else
{
// Figure out which provider to use
ProviderInfo provider = null;
PSDriveInfo drive = null;
string providerPath =
Globber.GetProviderPath(
path,
context,
out provider,
out drive);
ContainerCmdletProvider providerInstance = GetContainerProviderInstance(provider);
if (drive != null)
{
context.Drive = drive;
}
if (!providerInstance.ItemExists(providerPath, context))
{
ItemNotFoundException pathNotFound =
new ItemNotFoundException(
providerPath,
"PathNotFound",
SessionStateStrings.PathNotFound);
throw pathNotFound;
}
if (recurse)
{
// The path did not contain glob characters but recurse was specified
// so do the enumeration manually
DoGetChildNamesManually(
providerInstance,
providerPath,
String.Empty,
returnContainers,
includeMatcher,
excludeMatcher,
context,
recurse,
depth);
}
else
{
// Since the path did not contain glob characters and recurse wasn't
// specified, we can have the provider write out the child names directly
GetChildNames(
providerInstance,
providerPath,
returnContainers,
context);
}
}
} // GetChildNames
internal void GetChildItems(string path, bool recurse, CmdletProviderContext context)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
if (context == null)
{
throw PSTraceSource.NewArgumentNullException("context");
}
ProviderInfo info = null;
if (recurse || LocationGlobber.ShouldPerformGlobbing(path, context))
{
bool flag = false;
try
{
if ((recurse && ((context.Include == null) || (context.Include.Count == 0))) && (!string.IsNullOrEmpty(path) && !this.IsItemContainer(path)))
{
string childName = this.GetChildName(path, context);
if (!string.Equals(childName, "*", StringComparison.OrdinalIgnoreCase) && (context.Include != null))
{
context.Include.Add(childName);
flag = true;
}
path = path.Substring(0, path.Length - childName.Length);
}
Collection<string> include = context.Include;
Collection<string> exclude = context.Exclude;
string filter = context.Filter;
if (recurse)
{
context.SetFilters(new Collection<string>(), new Collection<string>(), null);
}
CmdletProvider providerInstance = null;
Collection<string> collection3 = null;
try
{
collection3 = this.Globber.GetGlobbedProviderPathsFromMonadPath(path, false, context, out info, out providerInstance);
}
finally
{
context.SetFilters(include, exclude, filter);
}
if (recurse)
{
this.GetContainerProviderInstance(info);
}
bool flag2 = !LocationGlobber.StringContainsGlobCharacters(path);
if ((((recurse && !flag2) && ((include != null) && (include.Count == 0))) || ((include != null) && (include.Count > 0))) || ((exclude != null) && (exclude.Count > 0)))
{
foreach (string str4 in collection3)
{
if (context.Stopping)
{
return;
}
this.DoManualGetChildItems(providerInstance, str4, recurse, context, false);
}
}
else
{
foreach (string str5 in collection3)
{
if (context.Stopping)
{
return;
}
if ((flag2 || recurse) && this.IsItemContainer(providerInstance, str5, context))
{
this.GetChildItems(providerInstance, str5, recurse, context);
}
else
{
this.GetItemPrivate(providerInstance, str5, context);
}
}
}
}
finally
{
if (flag)
{
context.Include.Clear();
}
}
}
else
{
PSDriveInfo drive = null;
path = this.Globber.GetProviderPath(path, context, out info, out drive);
if (drive != null)
{
context.Drive = drive;
}
ContainerCmdletProvider containerProviderInstance = this.GetContainerProviderInstance(info);
if ((path != null) && this.ItemExists(containerProviderInstance, path, context))
{
if (this.IsItemContainer(containerProviderInstance, path, context))
{
this.GetChildItems(containerProviderInstance, path, recurse, context);
}
else
{
this.GetItemPrivate(containerProviderInstance, path, context);
}
}
else
{
ItemNotFoundException exception = new ItemNotFoundException(path, "PathNotFound", SessionStateStrings.PathNotFound);
throw exception;
}
}
}
} // RemoveProperty
/// <summary>
/// Gets the dynamic parameters for the remove-itemproperty cmdlet.
/// </summary>
///
/// <param name="path">
/// The path to the item if it was specified on the command line.
/// </param>
///
/// <param name="propertyName">
/// The name of the property that should be created.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <returns>
/// An object that has properties and fields decorated with
/// parsing attributes similar to a cmdlet class.
/// </returns>
///
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="path"/> refers to a provider that could not be found.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="path"/> refers to a drive that could not be found.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="path"/> refers to does
/// not support this operation.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
///
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
///
internal object RemovePropertyDynamicParameters(
string path,
string propertyName,
CmdletProviderContext context)
{
if (path == null)
{
return null;
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
CmdletProviderContext newContext =
new CmdletProviderContext(context);
newContext.SetFilters(
new Collection<string>(),
new Collection<string>(),
null);
Collection<string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
path,
true,
newContext,
out provider,
out providerInstance);
if (providerPaths.Count > 0)
{
// Get the dynamic parameters for the first resolved path
return RemovePropertyDynamicParameters(providerInstance, providerPaths[0], propertyName, newContext);
}
return null;
} // RemovePropertyDynamicParameters
} // MoveProperty
/// <summary>
/// Moves the specified property on the specified item to the specified property
/// on the destination item. The source and destination items can be the same item.
/// </summary>
///
/// <param name="sourcePaths">
/// The path(s) to the item(s) to move the property from.
/// </param>
///
/// <param name="sourceProperty">
/// The name of the property to be moved.
/// </param>
///
/// <param name="destinationPath">
/// The path to the item to move the property to.
/// </param>
///
/// <param name="destinationProperty">
/// The name of the property to move the property to.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="sourcePath"/>, <paramref name="sourceProperty"/>,
/// <paramref name="destinationPath"/>, or <paramref name="destinationProperty"/>
/// is null.
/// </exception>
///
/// <exception cref="ArgumentException">
/// If <paramref name="destinationPath"/> resolves to more than one item.
/// </exception>
///
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="sourcePath"/> refers to a provider that could not be found.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="sourcePath"/> refers to a drive that could not be found.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="sourcePath"/> refers to does
/// not support this operation.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
///
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
///
internal void MoveProperty(
string[] sourcePaths,
string sourceProperty,
string destinationPath,
string destinationProperty,
CmdletProviderContext context)
{
if (sourcePaths == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
if (sourceProperty == null)
{
throw PSTraceSource.NewArgumentNullException("sourceProperty");
}
if (destinationPath == null)
{
throw PSTraceSource.NewArgumentNullException("destinationPath");
}
if (destinationProperty == null)
{
throw PSTraceSource.NewArgumentNullException("destinationProperty");
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
// We shouldn't be filtering the destination path
CmdletProviderContext destinationContext = new CmdletProviderContext(context);
destinationContext.SetFilters(
new Collection<string>(),
new Collection<string>(),
null);
Collection<string> destinationProviderPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
destinationPath,
false,
destinationContext,
out provider,
out providerInstance);
if (destinationProviderPaths.Count > 1)
{
ArgumentException argException =
PSTraceSource.NewArgumentException(
"destinationPath",
SessionStateStrings.MovePropertyDestinationResolveToSingle);
context.WriteError(new ErrorRecord(argException, argException.GetType().FullName, ErrorCategory.InvalidArgument, destinationProviderPaths));
}
else
{
foreach (string sourcePath in sourcePaths)
{
if (sourcePath == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
Collection<string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
sourcePath,
false,
context,
out provider,
out providerInstance);
foreach (string providerPath in providerPaths)
{
MoveProperty(providerInstance, providerPath, sourceProperty, destinationProviderPaths[0], destinationProperty, context);
}
}
}
} // MoveProperty
} // CopyProperty
/// <summary>
/// Copies the specified property on the specified item to the specified property
/// on the destination item. The source and destination items can be the same item.
/// </summary>
///
/// <param name="sourcePaths">
/// The path(s) to the item(s) to copy the property from.
/// </param>
///
/// <param name="sourceProperty">
/// The name of the property to be copied.
/// </param>
///
/// <param name="destinationPath">
/// The path to the item to copy the property to.
/// </param>
///
/// <param name="destinationProperty">
/// The name of the property to copy the property to.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="sourcePath"/>, <paramref name="sourceProperty"/>,
/// <paramref name="destinationPath"/>, or <paramref name="destinationProperty"/>
/// is null.
/// </exception>
///
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="sourcePath"/> refers to a provider that could not be found.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="sourcePath"/> refers to a drive that could not be found.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="sourcePath"/> refers to does
/// not support this operation.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
///
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
///
internal void CopyProperty(
string[] sourcePaths,
string sourceProperty,
string destinationPath,
string destinationProperty,
CmdletProviderContext context)
{
if (sourcePaths == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
if (sourceProperty == null)
{
throw PSTraceSource.NewArgumentNullException("sourceProperty");
}
if (destinationPath == null)
{
throw PSTraceSource.NewArgumentNullException("destinationPath");
}
if (destinationProperty == null)
{
throw PSTraceSource.NewArgumentNullException("destinationProperty");
}
foreach (string sourcePath in sourcePaths)
{
if (sourcePath == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
Collection<string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
sourcePath,
false,
context,
out provider,
out providerInstance);
if (providerPaths.Count > 0)
{
// Save off the original filters
Collection<string> includeFilters = context.Include;
Collection<string> excludeFilters = context.Exclude;
string filterString = context.Filter;
// now modify the filters so that the destination isn't filtered
context.SetFilters(
new Collection<string>(),
new Collection<string>(),
null);
Collection<string> providerDestinationPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
destinationPath,
false,
context,
out provider,
out providerInstance);
// Now reapply the filters
context.SetFilters(
includeFilters,
excludeFilters,
filterString);
foreach (string providerPath in providerPaths)
{
foreach (string providerDestinationPath in providerDestinationPaths)
{
CopyProperty(providerInstance, providerPath, sourceProperty, providerDestinationPath, destinationProperty, context);
}
}
}
}
} // CopyProperty
} // CopyRecurseToSingleContainer
/// <summary>
/// Gets the dynamic parameters for the copy-item cmdlet.
/// </summary>
///
/// <param name="path">
/// The path to the item if it was specified on the command line.
/// </param>
///
/// <param name="destination">
/// The path of the item to copy to.
/// </param>
///
/// <param name="recurse">
/// Tells the provider to recurse sub-containers when copying.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <returns>
/// An object that has properties and fields decorated with
/// parsing attributes similar to a cmdlet class.
/// </returns>
///
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="path"/> refers to a provider that could not be found.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="path"/> refers to a drive that could not be found.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="path"/> refers to does
/// not support this operation.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
///
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
///
internal object CopyItemDynamicParameters(
string path,
string destination,
bool recurse,
CmdletProviderContext context)
{
if (path == null)
{
return null;
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
CmdletProviderContext newContext =
new CmdletProviderContext(context);
newContext.SetFilters(
new Collection<string>(),
new Collection<string>(),
null);
string providerPath = null;
bool pathNotFoundOnClient = false;
try
{
Collection<string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
path,
true,
newContext,
out provider,
out providerInstance);
if (providerPaths.Count > 0)
providerPath = providerPaths[0];
}
catch (DriveNotFoundException)
{
// This exception is expected for remote sessions where drives exist in a remote session but not
// on the client.
pathNotFoundOnClient = true;
}
catch (ItemNotFoundException)
{
// This exception is expected for remote sessions where item exist in a remote session but not
// on the client.
pathNotFoundOnClient = true;
}
if (pathNotFoundOnClient)
{
// At this point, we don't know if this is a remote use of copy-item because the FromSession
// and ToSession dynamic parameters have not been retrieved yet.
// Ignore these exceptions and use the FileSystem provider as default. If this is a real drive
// issue, or if the item does not exist, it will be caught later when the drive or item path is used.
var fileSystemProviders = Providers["FileSystem"];
if (fileSystemProviders.Count > 0)
{
providerPath = path;
providerInstance = ExecutionContext.EngineSessionState.GetProviderInstance(
fileSystemProviders[0]);
}
}
if (providerPath != null)
{
// Get the dynamic parameters for the first resolved path
return CopyItemDynamicParameters(providerInstance, providerPath, destination, recurse, newContext);
}
return null;
} // CopyItemDynamicParameters
} // GetChildNames
/// <summary>
/// Gets the dynamic parameters for the get-childitem -name cmdlet.
/// </summary>
///
/// <param name="path">
/// The path to the item if it was specified on the command line.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <returns>
/// An object that has properties and fields decorated with
/// parsing attributes similar to a cmdlet class.
/// </returns>
///
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="path"/> refers to a provider that could not be found.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="path"/> refers to a drive that could not be found.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="path"/> refers to does
/// not support this operation.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
///
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
///
internal object GetChildNamesDynamicParameters(
string path,
CmdletProviderContext context)
{
if (path == null)
{
return null;
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
CmdletProviderContext newContext =
new CmdletProviderContext(context);
newContext.SetFilters(
new Collection<string>(),
new Collection<string>(),
null);
Collection<string> providerPaths = null;
try
{
providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
path,
true,
newContext,
out provider,
out providerInstance);
}
catch (ItemNotFoundException)
{
// If the provided path is like c:\fakepath\aa*, since we cannot resolve c:\fakepath, an
// ItemNotFoundException will be thrown out. In this case, we catch the exception
// and check if the "providerInstance" is identified. If providerInstance is not null,
// we can carry on with the get-dynamic-parameters method.
if (providerInstance == null)
{
throw;
}
}
object result = null;
if (providerPaths != null && providerPaths.Count > 0)
{
// Get the dynamic parameters for the first resolved path
result = GetChildNamesDynamicParameters(providerInstance, providerPaths[0], newContext);
}
else
{
if (providerInstance != null)
{
PSDriveInfo drive = null;
// If we get here, the GetProviderPath should always succeed. This method was already invoked
// in the call to GetGlobbedProviderPathsFromMonadPath, and since "providerInstance" is not null,
// the invocation in method GetGlobbedProviderPathsFromMonadPath should succeed.
string providerPath = Globber.GetProviderPath(path, context, out provider, out drive);
if (providerPath != null)
{
result = GetChildNamesDynamicParameters(providerInstance, providerPath, newContext);
}
}
}
return result;
} // GetChildNamesDynamicParameters
} // Exists
/// <summary>
/// Gets the dynamic parameters for the test-path cmdlet.
/// </summary>
///
/// <param name="path">
/// The path to the item if it was specified on the command line.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <returns>
/// An object that has properties and fields decorated with
/// parsing attributes similar to a cmdlet class.
/// </returns>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="path"/> is null.
/// </exception>
///
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="path"/> refers to a provider that could not be found.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="path"/> refers to a drive that could not be found.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="path"/> refers to does
/// not support this operation.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
///
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
///
internal object ItemExistsDynamicParameters(string path, CmdletProviderContext context)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
CmdletProviderContext newContext =
new CmdletProviderContext(context);
newContext.SetFilters(
new Collection<string>(),
new Collection<string>(),
null);
Collection<string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
path,
true,
newContext,
out provider,
out providerInstance);
if (providerPaths.Count > 0)
{
// Get the dynamic parameters for the first resolved path
return ItemExistsDynamicParameters(providerInstance, providerPaths[0], newContext);
}
return null;
} // ItemExistsDynamicParameters
} // GenerateNewPathsWithGlobLeaf
/// <summary>
/// Gets the child names in the specified path by using the provider
/// </summary>
///
/// <param name="dir">
/// The path of the directory to get the child names from. If this is an Msh Path,
/// dirIsProviderPath must be false, If this is a provider-internal path,
/// dirIsProviderPath must be true.
/// </param>
///
/// <param name="leafElement">
/// The element that we are ultimately looking for. Used to set filters on the context
/// if desired.
/// </param>
///
/// <param name="getAllContainers">
/// Determines if the GetChildNames call should get all containers even if they don't
/// match the filter.
/// </param>
///
/// <param name="context">
/// The context to be used for the command. The context is copied to a new context, the
/// results are accumulated and then returned.
/// </param>
///
/// <param name="dirIsProviderPath">
/// Specifies whether the dir parameter is a provider-internal path (true) or Msh Path (false).
/// </param>
///
/// <param name="drive">
/// The drive to use to qualify the Msh path if dirIsProviderPath is false.
/// </param>
///
/// <param name="provider">
/// The provider to use to get the child names.
/// </param>
///
/// <param name="modifiedDirPath">
/// Returns the modified dir path. If dirIsProviderPath is true, this is the unescaped dir path.
/// If dirIsProviderPath is false, this is the unescaped resolved provider path.
/// </param>
///
/// <returns>
/// A collection of PSObjects whose BaseObject is a string that contains the name of the child.
/// </returns>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="dir"/> or <paramref name="drive"/> is null.
/// </exception>
///
/// <exception cref="ProviderNotFoundException">
/// If the path is a provider-qualified path for a provider that is
/// not loaded into the system.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="path"/> refers to a drive that could not be found.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider used to build the path threw an exception.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="path"/> represents is not a NavigationCmdletProvider
/// or ContainerCmdletProvider.
/// </exception>
///
/// <exception cref="InvalidOperationException">
/// If the <paramref name="path"/> starts with "~" and the home location is not set for
/// the provider.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider associated with the <paramref name="path"/> threw an
/// exception when its GetParentPath or MakePath was called while
/// processing the <paramref name="path"/>.
/// </exception>
///
/// <exception cref="PipelineStoppedException">
/// If <paramref name="context"/> has been signaled for
/// StopProcessing.
/// </exception>
///
/// <exception>
/// Any exception can be thrown by the provider that is called to build
/// the provider path.
/// </exception>
///
private Collection<PSObject> GetChildNamesInDir(
string dir,
string leafElement,
bool getAllContainers,
CmdletProviderContext context,
bool dirIsProviderPath,
PSDriveInfo drive,
ContainerCmdletProvider provider,
out string modifiedDirPath)
{
// See if the provider wants to convert the path and filter
string convertedPath = null;
string convertedFilter = null;
string originalFilter = context.Filter;
bool changedPathOrFilter = provider.ConvertPath(leafElement, context.Filter, ref convertedPath, ref convertedFilter, context);
if (changedPathOrFilter)
{
if (s_tracer.IsEnabled)
{
s_tracer.WriteLine("Provider converted path and filter.");
s_tracer.WriteLine("Original path: {0}", leafElement);
s_tracer.WriteLine("Converted path: {0}", convertedPath);
s_tracer.WriteLine("Original filter: {0}", context.Filter);
s_tracer.WriteLine("Converted filter: {0}", convertedFilter);
}
leafElement = convertedPath;
context.Filter = convertedFilter;
}
ReturnContainers returnContainers = ReturnContainers.ReturnAllContainers;
if (!getAllContainers)
{
returnContainers = ReturnContainers.ReturnMatchingContainers;
}
CmdletProviderContext getChildNamesContext =
new CmdletProviderContext(context);
// Remove the include/exclude filters from the new context
getChildNamesContext.SetFilters(
new Collection<string>(),
new Collection<string>(),
context.Filter);
try
{
// Use the provider to get the children
string unescapedDir = null;
modifiedDirPath = null;
if (dirIsProviderPath)
{
modifiedDirPath = unescapedDir = context.SuppressWildcardExpansion ? dir : RemoveGlobEscaping(dir);
}
else
{
Dbg.Diagnostics.Assert(
drive != null,
"Caller should verify that drive is not null when dirIsProviderPath is false");
// If the directory is an MSH path we must resolve it before calling GetChildNames()
// -- If the path is passed in by LiteralPath (context.SuppressWildcardExpansion == false), we surely should use 'dir' unchanged.
// -- If the path is passed in by Path (context.SuppressWildcardExpansion == true), we still should use 'dir' unchanged, in case that the special character
// in 'dir' is escaped
modifiedDirPath = GetMshQualifiedPath(dir, drive);
ProviderInfo providerIgnored = null;
CmdletProvider providerInstanceIgnored = null;
Collection<string> resolvedPaths =
GetGlobbedProviderPathsFromMonadPath(
modifiedDirPath,
false,
getChildNamesContext,
out providerIgnored,
out providerInstanceIgnored);
// After resolving the path, we unescape the modifiedDirPath if necessary.
modifiedDirPath = context.SuppressWildcardExpansion
? modifiedDirPath
: RemoveGlobEscaping(modifiedDirPath);
if (resolvedPaths.Count > 0)
{
unescapedDir = resolvedPaths[0];
}
else
{
// If there were no results from globbing but no
// exception was thrown, that means there was filtering.
// So return an empty collection and let the caller deal
// with it.
if (changedPathOrFilter)
{
context.Filter = originalFilter;
}
return new Collection<PSObject>();
}
}
if (provider.HasChildItems(unescapedDir, getChildNamesContext))
{
provider.GetChildNames(
unescapedDir,
returnContainers,
getChildNamesContext);
}
// First check to see if there were any errors, and write them
// to the real context if there are.
if (getChildNamesContext.HasErrors())
{
Collection<ErrorRecord> errors = getChildNamesContext.GetAccumulatedErrorObjects();
if (errors != null &&
errors.Count > 0)
{
foreach (ErrorRecord errorRecord in errors)
{
context.WriteError(errorRecord);
}
}
}
Collection<PSObject> childNamesObjectArray = getChildNamesContext.GetAccumulatedObjects();
if (changedPathOrFilter)
{
context.Filter = originalFilter;
}
return childNamesObjectArray;
}
finally
{
getChildNamesContext.RemoveStopReferral();
}
} // GetChildNamesInDir
private Collection<PSObject> GetChildNamesInDir(string dir, string leafElement, bool getAllContainers, CmdletProviderContext context, bool dirIsProviderPath, PSDriveInfo drive, ContainerCmdletProvider provider, out string modifiedDirPath)
{
string updatedPath = null;
string updatedFilter = null;
Collection<PSObject> collection4;
string filter = context.Filter;
bool flag = provider.ConvertPath(leafElement, context.Filter, ref updatedPath, ref updatedFilter, context);
if (flag)
{
tracer.WriteLine("Provider converted path and filter.", new object[0]);
tracer.WriteLine("Original path: " + leafElement, new object[0]);
tracer.WriteLine("Converted path: " + updatedPath, new object[0]);
tracer.WriteLine("Original filter: " + context.Filter, new object[0]);
tracer.WriteLine("Converted filter: " + updatedFilter, new object[0]);
leafElement = updatedPath;
context.Filter = updatedFilter;
}
ReturnContainers returnAllContainers = ReturnContainers.ReturnAllContainers;
if (!getAllContainers)
{
returnAllContainers = ReturnContainers.ReturnMatchingContainers;
}
CmdletProviderContext context2 = new CmdletProviderContext(context);
context2.SetFilters(new Collection<string>(), new Collection<string>(), context.Filter);
try
{
string path = null;
modifiedDirPath = null;
if (dirIsProviderPath)
{
modifiedDirPath = path = context.SuppressWildcardExpansion ? dir : RemoveGlobEscaping(dir);
}
else
{
modifiedDirPath = GetMshQualifiedPath(dir, drive);
ProviderInfo info = null;
CmdletProvider providerInstance = null;
Collection<string> collection = this.GetGlobbedProviderPathsFromMonadPath(modifiedDirPath, false, context2, out info, out providerInstance);
modifiedDirPath = context.SuppressWildcardExpansion ? modifiedDirPath : RemoveGlobEscaping(modifiedDirPath);
if (collection.Count > 0)
{
path = collection[0];
}
else
{
if (flag)
{
context.Filter = filter;
}
return new Collection<PSObject>();
}
}
if (provider.HasChildItems(path, context2))
{
provider.GetChildNames(path, returnAllContainers, context2);
}
if (context2.HasErrors())
{
Collection<ErrorRecord> accumulatedErrorObjects = context2.GetAccumulatedErrorObjects();
if ((accumulatedErrorObjects != null) && (accumulatedErrorObjects.Count > 0))
{
foreach (ErrorRecord record in accumulatedErrorObjects)
{
context.WriteError(record);
}
}
}
Collection<PSObject> accumulatedObjects = context2.GetAccumulatedObjects();
if (flag)
{
context.Filter = filter;
}
collection4 = accumulatedObjects;
}
finally
{
context2.RemoveStopReferral();
}
return collection4;
}
internal void GetChildNames(string path, ReturnContainers returnContainers, bool recurse, CmdletProviderContext context)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
Collection<WildcardPattern> includeMatcher = SessionStateUtilities.CreateWildcardsFromStrings(context.Include, WildcardOptions.IgnoreCase);
Collection<WildcardPattern> excludeMatcher = SessionStateUtilities.CreateWildcardsFromStrings(context.Exclude, WildcardOptions.IgnoreCase);
if (LocationGlobber.ShouldPerformGlobbing(path, context))
{
ProviderInfo info = null;
CmdletProvider providerInstance = null;
CmdletProviderContext context2 = new CmdletProviderContext(context);
context2.SetFilters(new Collection<string>(), new Collection<string>(), null);
Collection<string> collection3 = this.Globber.GetGlobbedProviderPathsFromMonadPath(path, false, context2, out info, out providerInstance);
if (context2.Drive != null)
{
context.Drive = context2.Drive;
}
bool flag = LocationGlobber.StringContainsGlobCharacters(path);
foreach (string str in collection3)
{
if (context.Stopping)
{
break;
}
if ((!flag || recurse) && this.IsItemContainer(providerInstance, str, context))
{
this.DoGetChildNamesManually(providerInstance, str, string.Empty, returnContainers, includeMatcher, excludeMatcher, context, recurse);
}
else if (providerInstance is NavigationCmdletProvider)
{
string text = this.GetChildName(providerInstance, str, context, false);
bool flag2 = SessionStateUtilities.MatchesAnyWildcardPattern(text, includeMatcher, true);
bool flag3 = SessionStateUtilities.MatchesAnyWildcardPattern(text, excludeMatcher, false);
if (flag2 && !flag3)
{
context.WriteObject(text);
}
}
else
{
context.WriteObject(str);
}
}
}
else
{
ProviderInfo provider = null;
PSDriveInfo drive = null;
string str3 = this.Globber.GetProviderPath(path, context, out provider, out drive);
ContainerCmdletProvider containerProviderInstance = this.GetContainerProviderInstance(provider);
if (drive != null)
{
context.Drive = drive;
}
if (!containerProviderInstance.ItemExists(str3, context))
{
ItemNotFoundException exception = new ItemNotFoundException(str3, "PathNotFound", SessionStateStrings.PathNotFound);
throw exception;
}
if (recurse)
{
this.DoGetChildNamesManually(containerProviderInstance, str3, string.Empty, returnContainers, includeMatcher, excludeMatcher, context, recurse);
}
else
{
this.GetChildNames(containerProviderInstance, str3, returnContainers, context);
}
}
}
internal object GetChildNamesDynamicParameters(string path, CmdletProviderContext context)
{
if (path == null)
{
return null;
}
ProviderInfo info = null;
CmdletProvider providerInstance = null;
CmdletProviderContext context2 = new CmdletProviderContext(context);
context2.SetFilters(new Collection<string>(), new Collection<string>(), null);
Collection<string> collection = null;
try
{
collection = this.Globber.GetGlobbedProviderPathsFromMonadPath(path, true, context2, out info, out providerInstance);
}
catch (ItemNotFoundException)
{
if (providerInstance == null)
{
throw;
}
}
object obj2 = null;
if ((collection != null) && (collection.Count > 0))
{
return this.GetChildNamesDynamicParameters(providerInstance, collection[0], context2);
}
if (providerInstance != null)
{
PSDriveInfo drive = null;
string str = this.Globber.GetProviderPath(path, context, out info, out drive);
if (str != null)
{
obj2 = this.GetChildNamesDynamicParameters(providerInstance, str, context2);
}
}
return obj2;
}
} // GetChildItems
/// <summary>
/// Gets the children of the specified item.
/// </summary>
///
/// <param name="path">
/// A relative or absolute path to the object to get the children of.
/// </param>
///
/// <param name="recurse">
/// If true, gets all the children in all the sub-containers of the specified
/// container. If false, only gets the immediate children of the specified
/// container.
/// </param>
///
/// <param name="depth">
/// Limits the depth of recursion; uint.MaxValue performs full recursion.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="path"/> or <paramref name="context"/> is null.
/// </exception>
///
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="path"/> refers to a provider that could not be found.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="path"/> refers to a drive that could not be found.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="path"/> refers to does
/// not support this operation.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
///
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
///
internal void GetChildItems(
string path,
bool recurse,
uint depth,
CmdletProviderContext context)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
if (context == null)
{
throw PSTraceSource.NewArgumentNullException("context");
}
ProviderInfo provider = null;
if ((recurse && !context.SuppressWildcardExpansion) || LocationGlobber.ShouldPerformGlobbing(path, context))
{
bool modifiedInclude = false;
try
{
// If we're recursing, do some path fixups to match user
// expectations:
if (recurse)
{
// dir c:\tem* -include *.ps1 -rec => No change
if ((context.Include == null) || (context.Include.Count == 0))
{
// dir c:\tem* -rec => dir c:\ -include tem* -rec
// dir tem* -rec => dir -include tem* -rec
// dir temp -rec
// Should glob paths and files that match tem*, but then
// recurse into all subdirectories and do the same for
// those directories.
if ((!String.IsNullOrEmpty(path)) && (!IsItemContainer(path)))
{
string childName = GetChildName(path, context);
if (!String.Equals(childName, "*", StringComparison.OrdinalIgnoreCase))
{
if (context.Include != null)
{
context.Include.Add(childName);
modifiedInclude = true;
}
}
string parentName = path.Substring(0, path.Length - childName.Length);
path = parentName;
}
}
}
// Save the include and exclude filters so that we can ignore
// them when doing recursion
Collection<string> include = context.Include;
Collection<string> exclude = context.Exclude;
string filter = context.Filter;
if (recurse)
{
context.SetFilters(
new Collection<string>(),
new Collection<string>(),
null);
}
CmdletProvider providerInstance = null;
Collection<string> providerPaths = null;
try
{
providerPaths = Globber.GetGlobbedProviderPathsFromMonadPath(
path,
false,
context,
out provider,
out providerInstance);
}
finally
{
// Reset the include and exclude filters
context.SetFilters(
include,
exclude,
filter);
}
// Ensure this is a container provider before recursing.
// GetContainerProviderInstance throws otherwise (as was done in V2.)
if (recurse)
{
ContainerCmdletProvider unused = GetContainerProviderInstance(provider);
}
bool getChildrenBecauseNoGlob = !LocationGlobber.StringContainsGlobCharacters(path);
// If we are doing recursion and we have include or exclude
// filters the recursion must be done manually.
// Win8: 279933 Perf degradation: recursive get-childitem is 100% slower than win7
// To fix this Perf regression, using getChildrenBecauseNoGlob (+recurse) variables
// to decide when to use ManualGetChildItems and when not to.
if (
(recurse && !getChildrenBecauseNoGlob && (include != null) && (include.Count == 0)) ||
(include != null && include.Count > 0) ||
(exclude != null && exclude.Count > 0))
{
// Do the recursion manually so that we can apply the
// include and exclude filters
foreach (string providerPath in providerPaths)
{
// Making sure to obey the StopProcessing.
if (context.Stopping)
{
return;
}
int unUsedChildrenNotMatchingFilterCriteria = 0;
ProcessPathItems(providerInstance, providerPath, recurse, context, out unUsedChildrenNotMatchingFilterCriteria, ProcessMode.Enumerate);
}
}
else
{
// If the path wasn't globbed or we are recursing then we want to get the
// children of the path. If we were globbing and we are not recursing
// then we just want to get the item for the resolved paths.
foreach (string providerPath in providerPaths)
{
// Making sure to obey the StopProcessing.
if (context.Stopping)
{
return;
}
if ((getChildrenBecauseNoGlob || recurse) && IsItemContainer(providerInstance, providerPath, context))
{
GetChildItems(providerInstance, providerPath, recurse, depth, context);
}
else
{
GetItemPrivate(providerInstance, providerPath, context);
}
}
}
}
finally
{
if (modifiedInclude)
{
context.Include.Clear();
}
}
}
else
{
PSDriveInfo drive = null;
string originalPath = path;
path =
Globber.GetProviderPath(
path,
context,
out provider,
out drive);
if (drive != null)
{
context.Drive = drive;
}
ContainerCmdletProvider providerInstance = GetContainerProviderInstance(provider);
if (path != null && this.ItemExists(providerInstance, path, context))
{
if (IsItemContainer(providerInstance, path, context))
{
GetChildItems(providerInstance, path, recurse, depth, context);
}
else
{
GetItemPrivate(providerInstance, path, context);
}
}
else
{
ItemNotFoundException pathNotFound =
new ItemNotFoundException(
path,
"PathNotFound",
SessionStateStrings.PathNotFound);
throw pathNotFound;
}
}
} // GetChildItems
