schubduese
asked on
C# Scan Directories recusively with given Maxdepth
I have the followin class, scanning all Subdirectories of a given Directory. I would like to add a new parameter "Maxdepth", so it only scans with a maximum Depth of the given param
e.g.
Dir 1
Dir 1.1
Dir 1.1.1
Dir 1.1.1.1 -> should not be scanned
How can I count the actual depth and go to the next directory?
Actualy I have 3 Arguments:
1. List with Include Paths
2. List with exclude paths
3. Boolean for recursive scan
The 4. Parameter should be the Maxdepth
e.g.
Dir 1
Dir 1.1
Dir 1.1.1
Dir 1.1.1.1 -> should not be scanned
How can I count the actual depth and go to the next directory?
Actualy I have 3 Arguments:
1. List with Include Paths
2. List with exclude paths
3. Boolean for recursive scan
The 4. Parameter should be the Maxdepth
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Management;
using System.Xml.Linq;
using System.IO;
using System.Security;
using System.Security.AccessControl;
using System.Security.Principal;
using System.DirectoryServices.ActiveDirectory;
using System.DirectoryServices;
using System.Windows.Forms;
namespace DirectoryScan
{
public class ACL
{
/// <summary>
/// Variables
/// </summary>
private String mDirectoryName = string.Empty;
private String mAccountName = string.Empty;
private String mTyp = string.Empty;
private String mRights = string.Empty;
private String mInherited = string.Empty;
private String mInheritanceFlags = string.Empty;
private String mPropagationFlags = string.Empty;
private int mDirectoryCount = 0;
/// <summary>
/// Default Constructor
/// </summary>
public ACL()
{
}
public static Dictionary<String, List<ACL>> GetACLInformation(List<Object> includePath, List<Object> excludePath, bool recursive)
{
// Create Collection Instance
Dictionary<String,List<ACL>> aclSet = new Dictionary<String,List<ACL>>();
foreach (String driveInfo in includePath)
{
// Call recursive private Method
readDir(new DirectoryInfo(driveInfo), excludePath, aclSet, recursive);
}
// Return Dictionary
return new Dictionary<string,List<ACL>>(aclSet);
}
private static void readDir(DirectoryInfo directory, List<Object> excludePath, Dictionary<String,List<ACL>> lAclSet, bool recursive)
{
try
{
// Check exclude Paths
if (! excludePath.Contains(directory.FullName.ToString().Trim()))
{
// Save Directory Name
String dirName = directory.FullName.ToString();
// Count Subfolders
DirectoryInfo[] subDirs = directory.GetDirectories();
String dirCount = subDirs.Length.ToString();
// Create Key
String key = dirName + ";" + dirCount;
// Security Object
DirectorySecurity ds = directory.GetAccessControl(AccessControlSections.Access);
// Showing access rules data
AuthorizationRuleCollection arc = ds.GetAccessRules(true, true, typeof(NTAccount));
// Create List
List<ACL> aclList = new List<ACL>();
foreach (FileSystemAccessRule ar in arc)
{
// Create Object
ACL acl = new ACL();
// Set Values
acl.AccountName = ar.IdentityReference.Value.ToString();
acl.Typ = ar.AccessControlType.ToString();
acl.Rights = ar.FileSystemRights.ToString();
acl.Inherited = ar.IsInherited.ToString();
acl.InheritanceFlags = ar.InheritanceFlags.ToString();
acl.PropagationFlags = ar.PropagationFlags.ToString();
// Add to List
aclList.Add(acl);
}
// Add to Dictionary
if (! lAclSet.ContainsKey(key))
{
lAclSet.Add(key, aclList);
}
}
// Search in Subfolders if recursive true
if (recursive)
{
foreach (DirectoryInfo subDirectory in directory.GetDirectories())
{
readDir(subDirectory, excludePath, lAclSet, recursive);
}
}
}
catch
{
return;
}
}
public String DirectoryName
{
get { return mDirectoryName; }
set { mDirectoryName = value; }
}
public String AccountName
{
get { return mAccountName; }
set { mAccountName = value; }
}
public String Typ
{
get { return mTyp; }
set { mTyp = value; }
}
public String Rights
{
get { return mRights; }
set { mRights = value; }
}
public String Inherited
{
get { return mInherited; }
set { mInherited = value; }
}
public String InheritanceFlags
{
get { return mInheritanceFlags; }
set { mInheritanceFlags = value; }
}
public String PropagationFlags
{
get { return mPropagationFlags; }
set { mPropagationFlags = value; }
}
public int DirectoryCount
{
get { return mDirectoryCount; }
set { mDirectoryCount = value; }
}
}
}
ASKER
Yes, the parameter for depth is known... the question is how can I handle the depth!
you can use it to decide whether or not going down.
if (recursive && no more than the MaxDepth)
{
///.....
}
if (recursive && no more than the MaxDepth)
{
///.....
}
To clarify (pardon the terrible pseudo-code):
method([your arguments], int depth)
{
if (depth > maxDepth) return;
[your code...]
foreach (directory in directories)
{
method([your arguments], depth + 1);
}
}
ASKER
Probably my Question was not really clear, sorry for that, I'll start another try
The goal with maxdepth is, that the user can give a parameter with the depth, because he's probably not interested in the 3th, 4th etc. level.
So for an Director C:\Windows and a maxlevel of 1 he will scan every subdirectory directly under C:\Windows. With a maxlevel of 2, the scan will go one level deeper (e.g. C:\Windows\Folder1\Subfold er1)
Hope it's more understandable. Sorry for the circumstances...
The goal with maxdepth is, that the user can give a parameter with the depth, because he's probably not interested in the 3th, 4th etc. level.
So for an Director C:\Windows and a maxlevel of 1 he will scan every subdirectory directly under C:\Windows. With a maxlevel of 2, the scan will go one level deeper (e.g. C:\Windows\Folder1\Subfold
Hope it's more understandable. Sorry for the circumstances...
ASKER CERTIFIED SOLUTION
membership
This solution is only available to members.
To access this solution, you must be a member of Experts Exchange.
Or you can count from your structure.