Mapping network drives for users in a XML File (C#)

public class DriveSettings
{
    private enum ResourceScope
    {
        RESOURCE_CONNECTED = 1,
        RESOURCE_GLOBALNET,
        RESOURCE_REMEMBERED,
        RESOURCE_RECENT,
        RESOURCE_CONTEXT
    }
    private enum ResourceType
    {
        RESOURCETYPE_ANY,
        RESOURCETYPE_DISK,
        RESOURCETYPE_PRINT,
        RESOURCETYPE_RESERVED
    }
    private enum ResourceUsage
    {
        RESOURCEUSAGE_CONNECTABLE = 0x00000001,
        RESOURCEUSAGE_CONTAINER = 0x00000002,
        RESOURCEUSAGE_NOLOCALDEVICE = 0x00000004,
        RESOURCEUSAGE_SIBLING = 0x00000008,
        RESOURCEUSAGE_ATTACHED = 0x00000010
    }
    private enum ResourceDisplayType
    {
        RESOURCEDISPLAYTYPE_GENERIC,
        RESOURCEDISPLAYTYPE_DOMAIN,
        RESOURCEDISPLAYTYPE_SERVER,
        RESOURCEDISPLAYTYPE_SHARE,
        RESOURCEDISPLAYTYPE_FILE,
        RESOURCEDISPLAYTYPE_GROUP,
        RESOURCEDISPLAYTYPE_NETWORK,
        RESOURCEDISPLAYTYPE_ROOT,
        RESOURCEDISPLAYTYPE_SHAREADMIN,
        RESOURCEDISPLAYTYPE_DIRECTORY,
        RESOURCEDISPLAYTYPE_TREE,
        RESOURCEDISPLAYTYPE_NDSCONTAINER
    }
    [StructLayout(LayoutKind.Sequential)]
    private struct NETRESOURCE
    {
        public ResourceScope oResourceScope;
        public ResourceType oResourceType;
        public ResourceDisplayType oDisplayType;
        public ResourceUsage oResourceUsage;
        public string sLocalName;
        public string sRemoteName;
        public string sComments;
        public string sProvider;
    }
    [DllImport("mpr.dll")]
    private static extern int WNetAddConnection2
        (ref NETRESOURCE oNetworkResource, string sPassword,
        string sUserName, int iFlags);

    [DllImport("mpr.dll")]
    private static extern int WNetCancelConnection2
        (string sLocalName, uint iFlags, int iForce);

    public static void MapNetworkDrive(string sDriveLetter, string sNetworkPath)
    {
        if (sNetworkPath.Substring(sNetworkPath.Length - 1, 1) == @"\")
        {
            sNetworkPath = sNetworkPath.Substring(0, sNetworkPath.Length - 1);
        }

        NETRESOURCE oNetworkResource = new NETRESOURCE();
        oNetworkResource.oResourceType = ResourceType.RESOURCETYPE_DISK;
        oNetworkResource.sLocalName = sDriveLetter + ":";
        oNetworkResource.sRemoteName = sNetworkPath;

        if (IsDriveMapped(sDriveLetter))
        {
            DisconnectNetworkDrive(sDriveLetter, true);
        }

        WNetAddConnection2(ref oNetworkResource, null, null, 0);
    }

    public static int DisconnectNetworkDrive(string sDriveLetter, bool bForceDisconnect)
    {
        if (bForceDisconnect)
        {
            return WNetCancelConnection2(sDriveLetter + ":", 0, 1);
        }
        else
        {
            return WNetCancelConnection2(sDriveLetter + ":", 0, 0);
        }
    }

    public static bool IsDriveMapped(string sDriveLetter)
    {
        string[] DriveList = Environment.GetLogicalDrives();
        for (int i = 0; i < DriveList.Length; i++)
        {
            if (sDriveLetter + ":\\" == DriveList[i].ToString())
            {
                return true;
            }
        }
        return false;
    }
}

private void buMove_Click(object sender, EventArgs e)
    {
        bool success = true;
        if (teBoSource.Text == "")
        {
            MessageBox.Show("An obligatory field is not filled.");
        }
        else
        {
            int counter_move = 0;
            foreach (string path in pathlist)
            {
                sourcePath = pathlist[counter_move];
                fileName = System.IO.Path.GetFileName(sourcePath);

                XDocument source = XDocument.Load(@"C:\XMLFile1.xml");
                string ns = source.Root.Name.NamespaceName;
                XName itemName = XName.Get("PC", ns);

                foreach (XElement descendant in source.Descendants(itemName))
                {
                    driveLetter = descendant.Element(XName.Get("drive", ns)).Value;
                    destinationPath = descendant.Element(XName.Get("server", ns)).Value;

                    destinationFile = System.IO.Path.Combine(destinationPath, fileName);

                    if (!System.IO.Directory.Exists(destinationPath))
                    {
                        System.IO.Directory.CreateDirectory(destinationPath);
                    }

                    try
                    {                    
                        DriveSettings.MapNetworkDrive("Z", destinationPath);
                        System.IO.File.Copy(sourcePath, destinationFile, true);
                    }
                    catch (Exception)
                    {
                        MessageBox.Show("Unable to copy the selected file(s).");
                        success = false;
                    }
                    DriveSettings.DisconnectNetworkDrive(driveLetter, true);
                }
                counter_move += 1;                   
            }
        }
        if (success == true)
        {
            MessageBox.Show("The file(s) was/were copied successful.");
        }
    }
}