/// <summary>
/// Load the library using a number of options
/// </summary>
/// <param name="libraryName">The name of the library</param>
/// <param name="isReadOnly">If <B>true</B>, loads the library in read-only mode.</param>
/// <returns>A ShellLibrary Object</returns>
public static ShellLibrary Load(string libraryName, bool isReadOnly)
{
CoreHelpers.ThrowIfNotWin7();
IKnownFolder kf = KnownFolders.Libraries;
string librariesFolderPath = (kf != null) ? kf.Path : string.Empty;
Guid guid = new Guid(ShellIIDGuid.IShellItem);
string shellItemPath = System.IO.Path.Combine(librariesFolderPath, libraryName + FileExtension);
int hr = ShellNativeMethods.SHCreateItemFromParsingName(shellItemPath, IntPtr.Zero, ref guid, out IShellItem nativeShellItem);
if (!CoreErrorHelper.Succeeded(hr))
{
throw new ShellException(hr);
}
INativeShellLibrary nativeShellLibrary = (INativeShellLibrary) new ShellLibraryCoClass();
AccessModes flags = isReadOnly ?
AccessModes.Read :
AccessModes.ReadWrite;
nativeShellLibrary.LoadLibraryFromItem(nativeShellItem, flags);
ShellLibrary library = new ShellLibrary(nativeShellLibrary);
try {
library.nativeShellItem = (IShellItem2)nativeShellItem;
library.Name = libraryName;
return(library);
} catch {
library.Dispose();
throw;
}
}
private void UpdateProperties(IKnownFolder folder)
{
// TODO - Make XAML only
// There is currently no way to get all the KnownFolder properties in a collection
// that can be use for binding to a listbox. Create our own properties collection with name/value pairs
Collection<KnownFolderProperty> properties = new Collection<KnownFolderProperty>();
properties.Add(new KnownFolderProperty { Property = "Canonical Name", Value = folder.CanonicalName });
properties.Add(new KnownFolderProperty { Property = "Category", Value = folder.Category });
properties.Add(new KnownFolderProperty { Property = "Definition Options", Value = folder.DefinitionOptions });
properties.Add(new KnownFolderProperty { Property = "Description", Value = folder.Description });
properties.Add(new KnownFolderProperty { Property = "File Attributes", Value = folder.FileAttributes });
properties.Add(new KnownFolderProperty { Property = "Folder Id", Value = folder.FolderId });
properties.Add(new KnownFolderProperty { Property = "Folder Type", Value = folder.FolderType });
properties.Add(new KnownFolderProperty { Property = "Folder Type Id", Value = folder.FolderTypeId });
properties.Add(new KnownFolderProperty { Property = "Localized Name", Value = folder.LocalizedName });
properties.Add(new KnownFolderProperty { Property = "Localized Name Resource Id", Value = folder.LocalizedNameResourceId });
properties.Add(new KnownFolderProperty { Property = "Parent Id", Value = folder.ParentId });
properties.Add(new KnownFolderProperty { Property = "ParsingName", Value = folder.ParsingName });
properties.Add(new KnownFolderProperty { Property = "Path", Value = folder.Path });
properties.Add(new KnownFolderProperty { Property = "Relative Path", Value = folder.RelativePath });
properties.Add(new KnownFolderProperty { Property = "Redirection", Value = folder.Redirection });
properties.Add(new KnownFolderProperty { Property = "Security", Value = folder.Security });
properties.Add(new KnownFolderProperty { Property = "Tooltip", Value = folder.Tooltip });
properties.Add(new KnownFolderProperty { Property = "Tooltip Resource Id", Value = folder.TooltipResourceId });
// Bind the collection to the properties listbox.
PropertiesListBox.ItemsSource = properties;
}
/// <summary>
/// パス情報を初期化します。
/// </summary>
/// <param name="knownFolderInterface"></param>
private void InitializePath(IKnownFolder knownFolderInterface)
{
Contract.Requires(knownFolderInterface != null);
this.Path = String.Empty;
if (this.Category == KnownFolderCategories.Virtual)
{
this.PathExists = false;
}
else
{
try
{
this.Path = knownFolderInterface.GetPath(0);
this.PathExists = true;
}
catch (FileNotFoundException)
{
this.PathExists = false;
}
catch (DirectoryNotFoundException)
{
this.PathExists = false;
}
}
}
/// <summary>
/// <see cref="KNOWNFOLDER_DEFINITION" />を取得し、
/// 各プロパティを初期化します。
/// </summary>
/// <param name="knownFolderInterface"></param>
private void Initialize(IKnownFolder knownFolderInterface)
{
Contract.Requires(knownFolderInterface != null);
KNOWNFOLDER_DEFINITION knownFolderDefinition;
knownFolderInterface.GetFolderDefinition(out knownFolderDefinition);
try
{
this.ParsingName = PtrToString(knownFolderDefinition.pszParsingName);
this.CanonicalName = PtrToString(knownFolderDefinition.pszName);
this.Category = (KnownFolderCategories)knownFolderDefinition.category;
this.Description = PtrToString(knownFolderDefinition.pszDescription);
this.ParentId = knownFolderDefinition.fidParent;
this.RelativePath = PtrToString(knownFolderDefinition.pszRelativePath);
InitializeResourceProperties(knownFolderDefinition);
this.FolderDefinitionFlags = (FolderDefinitionFlags)knownFolderDefinition.kfdFlags;
this.FileAttributes = (FileAttributes)knownFolderDefinition.dwAttributes;
this.FolderTypeId = knownFolderDefinition.ftidType;
this.FolderType = String.Empty;
this.FolderId = knownFolderInterface.GetId();
InitializePath(knownFolderInterface);
this.Redirection = (RedirectionCapability)knownFolderInterface.GetRedirectionCapabilities();
this.Security = PtrToString(knownFolderDefinition.pszSecurity);
}
finally
{
ShellNativeMethods.FreeKnownFolderDefinitionFields(ref knownFolderDefinition);
}
}
/// <summary>
/// Creates a shell library in the Libraries Known Folder,
/// using the given IKnownFolder
/// </summary>
/// <param name="sourceKnownFolder">KnownFolder from which to create the new Shell Library</param>
/// <param name="isReadOnly">If <B>true</B> , opens the library in read-only mode.</param>
private ShellLibrary(IKnownFolder sourceKnownFolder, bool isReadOnly)
: this()
{
Debug.Assert(sourceKnownFolder != null);
// Keep a reference locally
knownFolder = sourceKnownFolder;
nativeShellLibrary = (INativeShellLibrary) new ShellLibraryCoClass();
AccessModes flags = isReadOnly ?
AccessModes.Read :
AccessModes.ReadWrite;
// Get the IShellItem2
base.nativeShellItem = ((ShellObject)sourceKnownFolder).NativeShellItem2;
Guid guid = sourceKnownFolder.FolderId;
// Load the library from the IShellItem2
try {
nativeShellLibrary.LoadLibraryFromKnownFolder(ref guid, flags);
} catch (InvalidCastException) {
throw new ArgumentException(LocalizedMessages.ShellLibraryInvalidLibrary, "sourceKnownFolder");
} catch (NotImplementedException) {
throw new ArgumentException(LocalizedMessages.ShellLibraryInvalidLibrary, "sourceKnownFolder");
}
}
public void VerifyDefaultFoldersInAllCollection()
{
ICollection<IKnownFolder> folders = KnownFolders.All;
PropertyInfo[] properties = typeof(KnownFolders).GetProperties(BindingFlags.Static | BindingFlags.Public);
foreach (PropertyInfo info in properties)
{
if (info.PropertyType == typeof(IKnownFolder))
{
IKnownFolder kf = null;
try
{
//if an exception is thrown, the known folder does not exist on the computer.
kf = (IKnownFolder)info.GetValue(null, null);
}
catch
{
continue;
}
Assert.Contains(folders, x => kf.FolderId == x.FolderId);
}
}
}
public void KnownFolder_GetRedirectionCaps()
{
IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Libraries);
folder.GetRedirectionCapabilities().Should().Be(KF_REDIRECTION_CAPABILITIES.REDIRECTABLE);
}
/// <summary>
/// Creates a shell library in the Libraries Known Folder,
/// using the given IKnownFolder
/// </summary>
/// <param name="sourceKnownFolder">KnownFolder from which to create the new Shell Library</param>
/// <param name="isReadOnly">If <B>true</B> , opens the library in read-only mode.</param>
private ShellLibrary(IKnownFolder sourceKnownFolder, bool isReadOnly)
{
CoreHelpers.ThrowIfNotWin7();
Debug.Assert(sourceKnownFolder != null);
// Keep a reference locally
knownFolder = sourceKnownFolder;
nativeShellLibrary = (INativeShellLibrary) new ShellLibraryCoClass();
ShellNativeMethods.STGM flags =
isReadOnly ?
ShellNativeMethods.STGM.Read :
ShellNativeMethods.STGM.ReadWrite;
// Get the IShellItem2
base.nativeShellItem = ((ShellObject)sourceKnownFolder).NativeShellItem2;
Guid guid = sourceKnownFolder.FolderId;
// Load the library from the IShellItem2
try
{
nativeShellLibrary.LoadLibraryFromKnownFolder(ref guid, flags);
}
catch (InvalidCastException)
{
throw new ArgumentException("The given known folder is not a valid library.", "sourceKnownFolder");
}
catch (NotImplementedException)
{
throw new ArgumentException("The given known folder is not a valid library.", "sourceKnownFolder");
}
}
/// <summary>
/// Returns a known folder given a globally unique identifier.
/// </summary>
/// <param name="knownFolderId">A GUID for the requested known folder.</param>
/// <returns>A known folder representing the specified name.</returns>
/// <exception cref="System.ArgumentException">Thrown if the given Known Folder ID is invalid.</exception>
public static IKnownFolder FromKnownFolderId(Guid knownFolderId)
{
IKnownFolderNative knownFolderNative;
IKnownFolderManager knownFolderManager = (IKnownFolderManager) new KnownFolderManagerClass();
HRESULT hr = knownFolderManager.GetFolder(knownFolderId, out knownFolderNative);
if (hr == HRESULT.S_OK)
{
IKnownFolder kf = GetKnownFolder(knownFolderNative);
if (kf != null)
{
return(kf);
}
else
{
throw new ArgumentException("Given Known Folder ID is invalid.", "knownFolderId");
}
}
else
{
throw Marshal.GetExceptionForHR((int)hr);
}
}
public void KnownFolder_GetCategory()
{
IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows);
folder.GetCategory().Should().Be(KF_CATEGORY.FIXED);
}
public void KnownFolderManager_GetKnownFolder()
{
IKnownFolderManager manager = ShellMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows);
folder.Should().NotBeNull();
}
public void KnownFolder_GetRedirectionCaps()
{
IKnownFolderManager manager = ShellMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KnownFolderIds.Libraries);
folder.GetRedirectionCapabilities().Should().Be(KnownFolderRedirectionCapabilities.Redirectable);
}
public void KnownFolder_GetId()
{
IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows);
folder.GetId().Should().Be(KNOWNFOLDERID.Windows);
}
private void navigateButton_Click(object sender, EventArgs e)
{
if (this.pathEdit.Text.Value.StartsWith("::{"))
{
try
{
IKnownFolder kf = KnownFolderHelper.FromParsingName(this.pathEdit.Text.Value);
this.explorerBrowser.Navigate((ShellObject)kf);
}
catch
{
logError("Navigation not possible. Failed to retrieve known folder.");
}
return;
}
if (!this.pathEdit.Items.Contains(this.pathEdit.Text.Value))
{
NavigateToFolderOrArchive(this.pathEdit.Text.Value);
}
else
{
NavigateToSpecialFolder(this.pathEdit.Text.Value);
}
}
/// <summary>
/// Load the library using a number of options
/// </summary>
/// <param name="sourceKnownFolder">A known folder.</param>
/// <param name="isReadOnly">If <B>true</B>, opens the library in read-only mode.</param>
/// <returns>A ShellLibrary Object</returns>
public static ShellLibrary Load(
IKnownFolder sourceKnownFolder,
bool isReadOnly)
{
CoreHelpers.ThrowIfNotWin7();
return(new ShellLibrary(sourceKnownFolder, isReadOnly));
}
public void KnownFolder_GetCategory()
{
IKnownFolderManager manager = ShellMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KnownFolderIds.Windows);
folder.GetCategory().Should().Be(KnownFolderCategory.Fixed);
}
public void ShellItem_GetDisplayName()
{
IKnownFolderManager manager = ShellMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KnownFolderIds.Windows);
IShellItem item = folder.GetShellItem(0, new Guid(InterfaceIds.IID_IShellItem));
item.GetDisplayName(ShellItemDisplayNames.NormalDisplay).Should().Be("Windows");
}
public void ShellItem_GetDisplayName()
{
IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows);
IShellItem item = folder.GetShellItem(0, new Guid(InterfaceIds.IID_IShellItem));
item.GetDisplayName(SIGDN.NORMALDISPLAY).Should().Be("Windows");
}
public void Dispose()
{
if (_knownFolder != null)
{
Marshal.ReleaseComObject(_knownFolder);
_knownFolder = null;
}
}
public void KnownFolder_GetFolderType()
{
// Most known folders don't have a FolderType associated and will throw a COMException with E_FAIL.
IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Contacts);
folder.GetFolderType().Should().Be(FOLDERTYPEID.Contacts);
}
internal KnownFolderDefinition(IKnownFolder nativeKnownFolder)
{
if (nativeKnownFolder == null)
{
throw new ArgumentNullException("nativeKnownFolder");
}
this.nativeDefinition = KNOWNFOLDER_DEFINITION.FromKnownFolder(nativeKnownFolder);
}
/// <summary>
/// Returns a known folder given its shell namespace parsing name, such as
/// <c>::{645FF040-5081-101B-9F08-00AA002F954E}</c> for the Recycle Bin.
/// </summary>
/// <param name="parsingName">The parsing name (or path) for the requested known folder.</param>
/// <returns>A known folder representing the specified name.</returns>
/// <exception cref="System.ArgumentException">Thrown if the given parsing name is invalid.</exception>
public static IKnownFolder FromParsingName(string parsingName)
{
if (parsingName == null)
{
throw new ArgumentNullException(nameof(parsingName));
}
IntPtr pidl = IntPtr.Zero;
IntPtr pidl2 = IntPtr.Zero;
try
{
pidl = ShellHelper.PidlFromParsingName(parsingName);
if (pidl == IntPtr.Zero)
{
throw new ArgumentException(LocalizedMessages.KnownFolderParsingName, nameof(parsingName));
}
// It's probably a special folder, try to get it
IKnownFolderNative knownFolderNative = KnownFolderHelper.FromPIDL(pidl);
if (knownFolderNative != null)
{
IKnownFolder kf = KnownFolderHelper.GetKnownFolder(knownFolderNative);
if (kf == null)
{
throw new ArgumentException(LocalizedMessages.KnownFolderParsingName, nameof(parsingName));
}
return(kf);
}
// No physical storage was found for this known folder
// We'll try again with a different name
// try one more time with a trailing \0
pidl2 = ShellHelper.PidlFromParsingName(parsingName.PadRight(1, '\0'));
if (pidl2 == IntPtr.Zero)
{
throw new ArgumentException(LocalizedMessages.KnownFolderParsingName, nameof(parsingName));
}
IKnownFolder kf2 = KnownFolderHelper.GetKnownFolder(KnownFolderHelper.FromPIDL(pidl));
if (kf2 == null)
{
throw new ArgumentException(LocalizedMessages.KnownFolderParsingName, nameof(parsingName));
}
return(kf2);
}
finally
{
ShellNativeMethods.ILFree(pidl);
ShellNativeMethods.ILFree(pidl2);
}
}
internal KnownFolderDefinition(IKnownFolder nativeKnownFolder)
{
if (nativeKnownFolder == null)
{
throw new ArgumentNullException("nativeKnownFolder");
}
this.nativeDefinition = KNOWNFOLDER_DEFINITION.FromKnownFolder(nativeKnownFolder);
}
internal KnownFolder(IKnownFolder nativeKnownFolder)
{
if (nativeKnownFolder == null)
{
throw new ArgumentNullException("nativeKnownFolder");
}
this.nativeKnownFolder = nativeKnownFolder;
}
/// <summary>
/// Initialize a new instance of the <see cref="ShellKnownFolder" /> class
/// to the specified <see cref="ShellItem" />, <see cref="IKnownFolder" /> and <see cref="FolderProperties" />.
/// </summary>
/// <param name="shellItem"><see cref="ShellItem" />.</param>
/// <param name="knownFolderInterface"><see cref="IKnownFolder" />.</param>
/// <exception cref="ArgumentNullException">
/// <para>
/// <paramref name="=shellItem" /> is a <c>null</c> reference.
/// </para>
/// or
/// <para>
/// <paramref name="knownFolderInterface" /> is a <c>null</c> reference.
/// </para>
/// </exception>
internal ShellKnownFolder(ShellItem shellItem, IKnownFolder knownFolderInterface)
: base(shellItem)
{
Contract.Requires <ArgumentNullException>(shellItem != null);
Contract.Requires <ArgumentNullException>(knownFolderInterface != null);
this.KnownFolderInterface = knownFolderInterface;
this.KnownFolderProperties = new FolderProperties(knownFolderInterface);
}
internal KnownFolder(IKnownFolder nativeKnownFolder)
{
if (nativeKnownFolder == null)
{
throw new ArgumentNullException("nativeKnownFolder");
}
this.nativeKnownFolder = nativeKnownFolder;
}
/*
* /// <summary>
* /// Returns a URI representation of the <see cref="ShellItem"/>.
* /// </summary>
* public Uri ToUri() {
* return this.ParsingName.StartsWith("::") ? new Uri("shell:///" + this.ParsingName) : new Uri(this.FileSystemPath);
* StringBuilder path = new StringBuilder("shell:///");
*
* if (this.ParsingName.StartsWith("::")) {
* path.Append(this.ParsingName);
* return new Uri(path.ToString());
* }
* return new Uri(this.FileSystemPath);
* }
*/
private void Initialize(Uri uri)
{
if (uri.Scheme == "file")
{
ComInterface = CreateItemFromParsingName(uri.LocalPath);
}
else if (uri.Scheme == "shell")
{
//InitializeFromShellUri(uri);
//TO_DO: add shell folders handling here
//KnownFolderManager manager = new KnownFolderManager();
string path = uri.GetComponents(UriComponents.Path, UriFormat.Unescaped);
string knownFolder;
string restOfPath;
int separatorIndex = path.IndexOf('/');
if (separatorIndex != -1)
{
knownFolder = path.Substring(0, separatorIndex);
restOfPath = path.Substring(separatorIndex + 1);
}
else
{
knownFolder = path;
restOfPath = string.Empty;
}
try {
IKnownFolder knownFolderI = KnownFolderHelper.FromParsingName(knownFolder);
if (knownFolderI != null)
{
ComInterface = (knownFolderI as ShellItem).ComInterface;
}
else if (knownFolder.StartsWith(KnownFolders.Libraries.ParsingName))
{
var lib = ShellLibrary.Load(Path.GetFileNameWithoutExtension(knownFolder), true);
if (lib != null)
{
ComInterface = lib.ComInterface;
}
}
}
catch {
}
if (restOfPath != string.Empty)
{
ComInterface = this[restOfPath.Replace('/', '\\')].ComInterface;
}
}
else
{
throw new InvalidOperationException("Invalid URI scheme");
}
}
/// <summary>
/// Shows the library management dialog which enables users to mange the library folders and default save location.
/// </summary>
/// <param name="sourceKnownFolder">A known folder.</param>
/// <param name="windowHandle">The parent window,or IntPtr.Zero for no parent</param>
/// <param name="title">A title for the library management dialog, or null to use the library name as the title</param>
/// <param name="instruction">An optional help string to display for the library management dialog</param>
/// <param name="allowAllLocations">If true, do not show warning dialogs about locations that cannot be indexed</param>
/// <remarks>If the library is already open in read-write mode, the dialog will not save the changes.</remarks>
public static void ShowManageLibraryUI(IKnownFolder sourceKnownFolder, IntPtr windowHandle, string title, string instruction, bool allowAllLocations)
{
// this method is not safe for MTA consumption and will blow
// Access Violations if called from an MTA thread so we wrap this
// call up into a Worker thread that performs all operations in a
// single threaded apartment
using (ShellLibrary shellLibrary = ShellLibrary.Load(sourceKnownFolder, true)) {
ShowManageLibraryUI(shellLibrary, windowHandle, title, instruction, allowAllLocations);
}
}
/// <summary>
/// Load the library using a number of options
/// </summary>
/// <param name="libraryName">The name of the library</param>
/// <param name="isReadOnly">If <B>true</B>, loads the library in read-only mode.</param>
/// <returns>A ShellLibrary Object</returns>
public static ShellLibrary Load(string libraryName, bool isReadOnly)
{
IKnownFolder kf = KnownFolders.Libraries;
string librariesFolderPath = kf != null ? kf.Path : string.Empty;
var guid = new Guid(InterfaceGuids.IShellItem);
string shellItemPath = System.IO.Path.Combine(librariesFolderPath, libraryName + FileExtension);
IShellItem nativeShellItem = Shell32.SHCreateItemFromParsingName(shellItemPath, IntPtr.Zero, guid);
return(Load_Helper(nativeShellItem, libraryName, isReadOnly));
}
void NavigateExplorerBrowser(object sender, SelectionChangedEventArgs args)
{
IKnownFolder folder = (IKnownFolder)((ListBox)sender).SelectedItem;
if (folder == null)
{
folder = (IKnownFolder)ShellFileSystemFolder.FromParsingName(KnownFolders.Desktop.ParsingName);
}
UpdateProperties(folder);
}
public void KnownFolder_GetIShellItem()
{
IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows);
IShellItem item = folder.GetShellItem(0, new Guid(InterfaceIds.IID_IShellItem));
item.Should().NotBeNull();
IShellItem2 item2 = (IShellItem2)folder.GetShellItem(0, new Guid(InterfaceIds.IID_IShellItem2));
item2.Should().NotBeNull();
}
public void KnownFolder_GetIdList()
{
IKnownFolderManager manager = ShellMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KnownFolderIds.Windows);
using (var id = folder.GetIDList(0))
{
id.IsInvalid.Should().BeFalse();
ShellMethods.GetNameFromId(id, ShellItemDisplayNames.ParentRelative).Should().Be("Windows");
}
}
public void KnownFolder_GetIdList()
{
IKnownFolderManager manager = ShellDesktopMethods.GetKnownFolderManager();
IKnownFolder folder = manager.GetFolder(KNOWNFOLDERID.Windows);
using (var id = folder.GetIDList(0))
{
id.IsInvalid.Should().BeFalse();
ShellDesktopMethods.GetNameFromId(id, SIGDN.PARENTRELATIVE).Should().Be("Windows");
}
}
public static KNOWNFOLDER_DEFINITION FromKnownFolder(IKnownFolder knownFolder)
{
if (knownFolder == null)
{
throw new ArgumentNullException("knownFolder");
}
KNOWNFOLDER_DEFINITION def;
using (var handles = new KnownFolderDefinitionHandles())
{
KNOWNFOLDER_DEFINITION_RAW rawDef;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
knownFolder.GetFolderDefinition(out rawDef);
try
{
handles.SecureHandles(ref rawDef);
}
finally
{
// in case SecureHandles throws
rawDef.FreeKnownFolderDefinitionFields();
}
}
def = new KNOWNFOLDER_DEFINITION(ref rawDef, handles);
}
return def;
}
public void FromCanonicalNameTest(IKnownFolder folder)
{
IKnownFolder test = KnownFolderHelper.FromCanonicalName(folder.CanonicalName);
Assert.True(folder.FolderId == test.FolderId);
}
public void FromParsingNameTest(IKnownFolder folder)
{
IKnownFolder test = KnownFolderHelper.FromParsingName(folder.ParsingName);
Assert.True(folder.FolderId == test.FolderId);
}
/// <summary>
/// Creates a new instance of KnownFolder.
/// </summary>
internal KnownFolder(IKnownFolder knownFolder)
{
Debug.Assert(knownFolder != null);
_knownFolder = knownFolder;
GetFolderProperties();
}
internal KnownFolder(IKnownFolder knownFolder)
{
_knownFolder = knownFolder;
}
