private static void SetEdition(DismSession session, string editionID, string productKey, Dism.DismProgressCallback progressCallback, object userData)
{
// Create a DismProgress object to wrap the callback and allow cancellation
DismProgress progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods._DismSetEdition(session, editionID, productKey, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult, session);
}
/// <summary>
/// Adds a single .cab or .msu file to a Windows® image.
/// </summary>
/// <param name="session">A valid DISM Session. The DISM Session must be associated with an image. You can associate a session with an image by using the OpenSession method.</param>
/// <param name="packagePath">A relative or absolute path to the .cab or .msu file being added or a folder containing the expanded files of a single .cab file.</param>
/// <param name="ignoreCheck">Specifies whether to ignore the internal applicability checks that are done when a package is added.</param>
/// <param name="preventPending">Specifies whether to add a package if it has pending online actions.</param>
/// <param name="progressCallback">A DismProgressCallback method to call when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
/// <exception cref="DismException">When a failure occurs.</exception>
/// <exception cref="OperationCanceledException">When the user requested the operation be canceled.</exception>
/// <exception cref="DismRebootRequiredException">When the operation requires a reboot to complete.</exception>
/// <exception cref="DismPackageNotApplicableException">When the package is not applicable to the specified session.</exception>
public static void AddPackage(DismSession session, string packagePath, bool ignoreCheck, bool preventPending, Microsoft.Dism.DismProgressCallback progressCallback, object userData)
{
// Create a DismProgress object to wrap the callback and allow cancellation
DismProgress progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismAddPackage(session, packagePath, ignoreCheck, preventPending, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult, session);
}
/// <summary>
/// Removes a package from an image.
/// </summary>
/// <param name="session">A valid DISM Session. The DISM Session must be associated with an image. You can associate a session with an image by using the DismOpenSession Function.</param>
/// <param name="identifier">Either an absolute path to a .cab file or the package name, depending on the PackageIdentifier parameter value.</param>
/// <param name="packageIdentifier">A DismPackageIdentifier Enumeration.</param>
/// <param name="progressCallback">A progress callback method to invoke when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
private static void RemovePackage(DismSession session, string identifier, DismPackageIdentifier packageIdentifier, Dism.DismProgressCallback progressCallback, object userData)
{
// Create a DismProgress object to wrap the callback and allow cancellation
var progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismRemovePackage(session, identifier, packageIdentifier, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult, session);
}
/// <summary>
/// Removes the capability from an image.
/// </summary>
/// <param name="session">A valid DISM Session. The DISM Session must be associated with an image. You can associate a session with an image by using the DismOpenSession Function.</param>
/// <param name="capabilityName">The name of the capability that is being removed</param>
/// <param name="progressCallback">A progress callback method to invoke when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
/// <exception cref="DismException">When a failure occurs.</exception>
/// <exception cref="OperationCanceledException">When the user requested the operation be canceled.</exception>
/// <exception cref="DismRebootRequiredException">When the operation requires a reboot to complete.</exception>
public static void RemoveCapability(DismSession session, string capabilityName, Dism.DismProgressCallback progressCallback, object userData)
{
// Create a DismProgress object to wrap the callback and allow cancellation
DismProgress progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismRemoveCapability(session, capabilityName, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult, session);
}
/// <summary>
/// Disables a feature in the current image.
/// </summary>
/// <param name="session">A valid DISM Session. The DISM Session must be associated with an image. You can associate a session with an image by using the DismOpenSession Function.</param>
/// <param name="featureName">The name of the feature that you want to disable. To disable more than one feature, separate each feature name with a semicolon.</param>
/// <param name="packageName">Optional. The name of the parent package that the feature is a part of.
///
/// This is an optional parameter. If no package is specified, then the default Windows® Foundation package is used.</param>
/// <param name="removePayload">Specifies whether to remove the files required to enable the feature.</param>
/// <param name="progressCallback">A progress callback method to invoke when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
/// <exception cref="DismException">When a failure occurs.</exception>
/// <exception cref="OperationCanceledException">When the user requested the operation be canceled.</exception>
/// <exception cref="DismRebootRequiredException">When the operation requires a reboot to complete.</exception>
public static void DisableFeature(DismSession session, string featureName, string packageName, bool removePayload, Microsoft.Dism.DismProgressCallback progressCallback, object userData)
{
// Create a DismProgress object to wrap the callback and allow cancellation
DismProgress progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismDisableFeature(session, featureName, packageName, removePayload, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult, session);
}
/// <summary>
/// Checks whether the image can be serviced or whether it is corrupted.
/// </summary>
/// <param name="session">A valid DISM Session. The DISM Session must be associated with an image. You can associate a session with an image by using the DismOpenSession Function.</param>
/// <param name="scanImage">Specifies whether to scan the image or just check for flags from a previous scan.</param>
/// <param name="progressCallback">A DismProgressCallback method to call when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
/// <returns>A <see cref="DismImageHealthState"/> indicating the health state of the image.</returns>
/// <exception cref="DismException">When a failure occurs.</exception>
/// <exception cref="OperationCanceledException">When the user requested the operation be canceled.</exception>
public static DismImageHealthState CheckImageHealth(DismSession session, bool scanImage, Microsoft.Dism.DismProgressCallback progressCallback, object userData)
{
// Create a DismProgress object to wrap the callback and allow cancellation
var progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismCheckImageHealth(session, scanImage, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero, out DismImageHealthState imageHealthState);
DismUtilities.ThrowIfFail(hresult);
return(imageHealthState);
}
/// <summary>
/// Repairs a corrupted image that has been identified as repairable by the CheckImageHealth Function.
/// </summary>
/// <param name="session">A valid DISM Session. The DISM Session must be associated with an image. You can associate a session with an image by using the DismOpenSession Function.</param>
/// <param name="limitAccess">Specifies whether the RestoreImageHealth method should contact Windows Update (WU) as a source location for downloading repair files. Before checking WU, DISM will check for the files in the sourcePaths provided and in any locations specified in the registry by Group Policy. If the files that are required to enable the feature are found in these other specified locations, this flag is ignored.</param>
/// <param name="sourcePaths">List of source locations to check for repair files.</param>
/// <param name="progressCallback">A progress callback method to invoke when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
/// <exception cref="DismException">When a failure occurs.</exception>
/// <exception cref="OperationCanceledException">When the user requested the operation be canceled.</exception>
/// <exception cref="DismRebootRequiredException">When the operation requires a reboot to complete.</exception>
public static void RestoreImageHealth(DismSession session, bool limitAccess, List <string> sourcePaths, Dism.DismProgressCallback progressCallback, object userData)
{
// Get the list of source paths as an array
var sourcePathsArray = sourcePaths?.ToArray() ?? new string[0];
// Create a DismProgress object to wrap the callback and allow cancellation
var progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismRestoreImageHealth(session, sourcePathsArray, (uint)sourcePathsArray.Length, limitAccess, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult, session);
}
/// <summary>
/// Commits the changes made to a Windows® image in a mounted .wim or .vhd file.
/// </summary>
/// <param name="session">A valid DISM Session. The DISM Session must be associated with an image. You can associate a session with an image by using the <see cref="OpenOfflineSession(string)" /> method.</param>
/// <param name="discardChanges">true or false to discard changes made to the image.</param>
/// <param name="progressCallback">A progress callback method to invoke when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
/// <exception cref="DismException">When a failure occurs.</exception>
/// <exception cref="OperationCanceledException">When the user requested the operation be canceled.</exception>
public static void CommitImage(DismSession session, bool discardChanges, Microsoft.Dism.DismProgressCallback progressCallback, object userData)
{
// Create the flags
UInt32 flags = discardChanges ? DISM_DISCARD_IMAGE : DISM_COMMIT_IMAGE;
// Create a DismProgress object to wrap the callback and allow cancellation
DismProgress progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismCommitImage(session, flags, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult, session);
}
/// <summary>
/// Mounts a WIM or VHD image file to a specified location.
/// </summary>
/// <param name="imageFilePath">The path to the WIM or VHD file on the local computer. A .wim, .vhd, or .vhdx file name extension is required.</param>
/// <param name="mountPath">The path of the location where the image should be mounted. This mount path must already exist on the computer. The Windows image in a .wim, .vhd, or .vhdx file can be mounted to an empty folder on an NTFS formatted drive. A Windows image in a .vhd or .vhdx file can also be mounted to an unassigned drive letter. You cannot mount an image to the root of the existing drive.</param>
/// <param name="imageIndex">The index of the image in the WIM file that you want to mount. For a VHD file, you must specify an index of 1.</param>
/// <param name="imageName">The name of the image that you want to mount.</param>
/// <param name="imageIdentifier">A DismImageIdentifier Enumeration value such as DismImageIndex.</param>
/// <param name="readOnly">Specifies if the image should be mounted in read-only mode.</param>
/// <param name="options">Specifies options to use when mounting an image.</param>
/// <param name="progressCallback">A progress callback method to invoke when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
private static void MountImage(string imageFilePath, string mountPath, int imageIndex, string imageName, DismImageIdentifier imageIdentifier, bool readOnly, DismMountImageOptions options, Microsoft.Dism.DismProgressCallback progressCallback, object userData)
{
// Determine the flags to pass to the native call
var flags = (readOnly ? DismApi.DISM_MOUNT_READONLY : DismApi.DISM_MOUNT_READWRITE) | (uint)options;
// Create a DismProgress object to wrap the callback and allow cancellation
var progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismMountImage(imageFilePath, mountPath, (uint)imageIndex, imageName, imageIdentifier, flags, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult);
}
/// <summary>
/// Unmounts a Windows image from a specified location.
/// </summary>
/// <param name="mountPath">A relative or absolute path to the mount directory of the image.</param>
/// <param name="commitChanges">Specifies whether or not the changes to the image should be saved.</param>
/// <param name="progressCallback">A progress callback method to invoke when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
/// <exception cref="DismException">When a failure occurs.</exception>
/// <exception cref="OperationCanceledException">When the user requested the operation be canceled.</exception>
public static void UnmountImage(string mountPath, bool commitChanges, Dism.DismProgressCallback progressCallback, object userData)
{
// Determine flags
var flags = commitChanges ? DismApi.DISM_COMMIT_IMAGE : DismApi.DISM_DISCARD_IMAGE;
// Create a DismProgress object to wrap the callback and allow cancellation
var progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismUnmountImage(mountPath, flags, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult);
}
/// <summary>
/// Add a capability to an image.
/// </summary>
/// <param name="session">A valid DISM Session. The DISM Session must be associated with an image. You can associate a session with an image by using the <see cref="OpenOfflineSession(string)" /> method.</param>
/// <param name="capabilityName">The name of the capability that is being added.</param>
/// <param name="limitAccess">The flag indicates whether WU/WSUS should be contacted as a source location for downloading the payload of a capability. If payload of the capability to be added exists, the flag is ignored.</param>
/// <param name="sourcePaths">A list of source locations. The function shall look up removed payload files from the locations specified in SourcePaths, and if not found, continue the search by contacting WU/WSUS depending on parameter LimitAccess.</param>
/// <param name="progressCallback">A progress callback method to invoke when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
/// <exception cref="DismException">When a failure occurs.</exception>
/// <exception cref="DismRebootRequiredException">When the operation requires a reboot to complete.</exception>
public static void AddCapability(DismSession session, string capabilityName, bool limitAccess, List <string> sourcePaths, Microsoft.Dism.DismProgressCallback progressCallback, object userData)
{
// Get the list of source paths as an array
string[] sourcePathsArray = sourcePaths?.ToArray() ?? new string[0];
// Create a DismProgress object to wrap the callback and allow cancellation
DismProgress progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismAddCapability(session, capabilityName, limitAccess, sourcePathsArray, (uint)sourcePathsArray.Length, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult, session);
}
/// <summary>
/// Enables a feature from the specified package path.
/// </summary>
/// <param name="session">A valid DISM Session. The DISM Session must be associated with an image. You can associate a session with an image by using the DismOpenSession Function.</param>
/// <param name="featureName">The name of the feature that is being enabled. To enable more than one feature, separate each feature name with a semicolon.</param>
/// <param name="identifier">A package name or absolute path.</param>
/// <param name="packageIdentifier">A DismPackageIdentifier value.</param>
/// <param name="limitAccess">Specifies whether Windows Update (WU) should be contacted as a source location for downloading files if none are found in other specified locations. Before checking WU, DISM will check for the files in the SourcePaths provided and in any locations specified in the registry by group policy. If the files required to enable the feature are still present on the computer, this flag is ignored.</param>
/// <param name="enableAll">Specifies whether to enable all dependencies of the feature. If the specified feature or any one of its dependencies cannot be enabled, none of them will be changed from their existing state.</param>
/// <param name="sourcePaths">A list of source locations to check for files needed to enable the feature.</param>
/// <param name="progressCallback">A progress callback method to invoke when progress is made.</param>
/// <param name="userData">Optional user data to pass to the DismProgressCallback method.</param>
/// <exception cref="DismException">When a failure occurs.</exception>
private static void EnableFeature(DismSession session, string featureName, string identifier, DismPackageIdentifier packageIdentifier, bool limitAccess, bool enableAll, List <string> sourcePaths, Microsoft.Dism.DismProgressCallback progressCallback, object userData)
{
// Get the list of source paths as an array
string[] sourcePathsArray = sourcePaths?.ToArray() ?? new string[0];
// Create a DismProgress object to wrap the callback and allow cancellation
var progress = new DismProgress(progressCallback, userData);
int hresult = NativeMethods.DismEnableFeature(
session: session,
featureName: featureName,
identifier: identifier,
packageIdentifier: identifier == null ? DismPackageIdentifier.None : packageIdentifier,
limitAccess: limitAccess,
sourcePaths: sourcePathsArray,
sourcePathCount: (uint)sourcePathsArray.Length,
enableAll: enableAll,
cancelEvent: progress.EventHandle,
progress: progress.DismProgressCallbackNative,
userData: IntPtr.Zero);
DismUtilities.ThrowIfFail(hresult, session);
}