/// <summary>
/// Returns a default instance of <see cref="ApplicationData"/> for the packaging of <see cref="executable"/>.
/// </summary>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException">
/// An <see cref="ArgumentException"/> is thrown if the value specified for <paramref name="executable"/> is invalid.
/// </exception>
/// <param name="executable"></param>
/// <returns></returns>
public static ApplicationData GetDefaultApplicationData(string executable)
{
if (string.IsNullOrEmpty(executable))
{
throw new ArgumentNullException("executable");
}
ApplicationData data = new ApplicationData();
data.Settings.RegistryEngineRuleCollection = RegistryRuleCollection.GetDefaultRuleCollection();
data.Files.RootDirectory = new ApplicationFile(".");
data.Files.Executable = new ApplicationFile(executable);
if (data.Files.Executable.Type != FileType.Executable)
{
throw new ArgumentException("The value specified for the executable is invalid.", "executable");
}
data.Files.RegistryDatabase = new ApplicationFile(_dbRegistry);
return(data);
}
public void BindDataSource(ApplicationData dataSource)
{
if (dataSource == null)
{
throw new ArgumentNullException("dataSource");
}
_data = dataSource;
if (_data.Settings.FileSystemEngineRuleCollection == null)
{
_data.Settings.FileSystemEngineRuleCollection = FileSystemRuleCollection.GetDefaultRuleCollection();
}
if (_data.Settings.RegistryEngineRuleCollection == null)
{
_data.Settings.RegistryEngineRuleCollection = RegistryRuleCollection.GetDefaultRuleCollection();
}
_fileSystemEngineSettingsPageContent.BindRuleCollection(_data.Settings.FileSystemEngineRuleCollection, FileSystemRuleCollectionUpdateEventHandler);
_registryEngineSettingsPageContent.BindRuleCollection(_data.Settings.RegistryEngineRuleCollection, RegistryRuleCollectionUpdateEventHandler);
Enabled = true;
}
/// <summary>
/// Initializes a new instance of <see cref="VirtualProcessStartInfo"/>
/// based on the <see cref="ApplicationData"/> specified.
/// </summary>
/// <exception cref="ArgumentNullException">
/// An <see cref="ArgumentNullException"/> is thrown if <paramref name="data"/> of one of its properties is null.
/// </exception>
/// <exception cref="ArgumentException">
/// An <see cref="ArgumentException"/> is thrown if any of the properties of <paramref name="data"/> is of the wrong type.
/// </exception>
/// <param name="data">The data to base the process on.</param>
/// <param name="workingDirectory">The working directory of the process to start.</param>
public VirtualProcessStartInfo(ApplicationData data, ApplicationFile workingDirectory)
{
if (data == null ||
data.Files.RegistryDatabase == null ||
data.Files.Executable == null ||
data.Files.RootDirectory == null)
{
throw new ArgumentNullException("data", "The data argument or one of its properties is null.");
}
if (workingDirectory == null)
{
throw new ArgumentNullException("workingDirectory", "The workingDirectory argument is null.");
}
if (data.Files.Executable.Type != FileType.Executable)
{
throw new ArgumentException("The ApplicationData specified contains an illegal value for the main executable.",
"data");
}
if (data.Files.RegistryDatabase.Type != FileType.Database)
{
throw new ArgumentException(
"The ApplicationData specified contains an illegal value for the registry database.",
"data");
}
if (workingDirectory.Type != FileType.Directory)
{
throw new ArgumentException("The working directory specified is not a directory.",
"workingDirectory");
}
_files = new ApplicationFiles
{
RegistryDatabase
= new ApplicationFile(Path.Combine(workingDirectory.FileName, data.Files.RegistryDatabase.FileName)),
Executable
= new ApplicationFile(Path.Combine(workingDirectory.FileName, data.Files.Executable.FileName)),
RootDirectory
= new ApplicationFile(Path.Combine(workingDirectory.FileName, data.Files.RootDirectory.FileName))
};
_arguments = "";
_workingDirectory = workingDirectory;
_fileSystemRuleCollection = data.Settings.FileSystemEngineRuleCollection ?? FileSystemRuleCollection.GetDefaultRuleCollection();
_registryRuleCollection = data.Settings.RegistryEngineRuleCollection ?? RegistryRuleCollection.GetDefaultRuleCollection();
}
/// <summary>
/// Initializes a new instance of <see cref="ProcessSynchronizer"/>.
/// The constructor will create default databases from the specified files.
/// </summary>
/// <param name="fileSystemRoot">The directory to use as root of the file system.</param>
/// <param name="fileSystemRuleCollection">The collection of engine rules to apply on the file system virtualization engine.</param>
/// <param name="registryDatabaseFile">The file to use with a default <see cref="RegistryDatabase"/>.</param>
/// <param name="registryRuleCollection">The collection of engine rules to apply on the registry virtualization engine.</param>
public ProcessSynchronizer(ApplicationFile fileSystemRoot, FileSystemRuleCollection fileSystemRuleCollection,
ApplicationFile registryDatabaseFile, RegistryRuleCollection registryRuleCollection)
{
if (fileSystemRoot.Type != FileType.Directory)
{
throw new ArgumentException("The root location specified for the file system is not valid.", "fileSystemRoot");
}
if (registryDatabaseFile.Type != FileType.Database)
{
throw new ArgumentException("The filename specified for the registry database is not valid.", "registryDatabaseFile");
}
_connectionStrings = new Dictionary <ConfigurationDataType, string>(2)
{
{ ConfigurationDataType.RegistryDatabaseFile, registryDatabaseFile.FileName },
{ ConfigurationDataType.FileSystemRoot, fileSystemRoot.FileName }
};
_fsRuleCollection = fileSystemRuleCollection;
_regRuleCollection = registryRuleCollection;
}
protected override EngineRuleCollection GetEmptyRuleCollection()
{
return(RegistryRuleCollection.GetEmptyRuleCollection());
}
/// <summary>
/// Initializes a new instance of <see cref="RegistrySwitch"/>.
/// </summary>
/// <param name="indexGenerator">The <see cref="IndexGenerator"/> to use for generating virtual key handles.</param>
/// <param name="knownKeys">A list of all known virtual registry keys.</param>
/// <param name="ruleCollection">The collection of engine rules to consider when deciding on a target registry.</param>
public RegistrySwitch(IndexGenerator indexGenerator, IDictionary <uint, VirtualRegistryKey> knownKeys, RegistryRuleCollection ruleCollection)
{
_transparentRegistry = new TransparentRegistry(indexGenerator);
_virtualRegistry = new VirtualRegistry(indexGenerator, knownKeys);
_engineRules = ruleCollection;
}