none
Acessando Compartilhamos de Redes com ASP.NET RRS feed

  • Pergunta

  • Pessoa, to tendo que desenvolver uma aplicação bem simples, onde o objetivo é pegar todos os arquivos de um diretório qualquer da minha máquina local e copiar para  dentro de um outro diretório, sendo que esse outro diretório é um compartilhamento de rede mapeado com Drive Y: na minha máquina...

     

    Fazer cópia entre arquivos de um diretório local, para outro diretório loca, eu consegui realizar ... o problema é quando eu preciso copiar para uma pasta compartilhada na rede...

     

    Acredito que o problema seja o usuário ASP.NET que não tem permissão de acesso ao compartilhamento... Se realmente este for o problema, como faço para usar um Login de Usuário válido no Windows que tenha permissão de acessar o compartilhamento ????

     

    Valeu...

    quinta-feira, 21 de setembro de 2006 20:53

Todas as Respostas

  • Frederico,

    Tenta mapear o um drive antes, passando seu usuário e senha. Comigo funcionou numa boa. Segue o exemplo:

    Aqui você está mapeando um drive como X.

    Map_Drive(@"\\maquina\D$", "X:");

    Código da rotina que faz o mapeamento:

    protected void Map_Drive(string sPath, string sDrive)

    {

    NetworkDrive oNetDrive = new NetworkDrive();

    //set propertys

    oNetDrive.Force = false;

    oNetDrive.Persistent = true;

    oNetDrive.LocalDrive = sDrive;

    oNetDrive.PromptForCredentials = false;

    oNetDrive.ShareName = sPath;

    oNetDrive.SaveCredentials = false;

    oNetDrive.MapDrive(@"seuusuario","suasenha");

    oNetDrive = null;

    }

    Espero que ajude.

    Abração.

    quinta-feira, 21 de setembro de 2006 21:15
  • Luciano

     

    Qual o namespace da NetworkDrive ???

    quinta-feira, 5 de julho de 2007 13:01
  • Esqueceram de te passar que isso é uma classe customizada...

    segue o código dela

     

    using System;
    using System.Windows.Forms;
    using System.Runtime.InteropServices;

    namespace SeuProjeto.Network
    {
     /// <summary>
     /// Network Drive Interface
     /// </summary>
     public class NetworkDrive{

      #region API
      [DllImport("mpr.dll")] private static extern int WNetAddConnection2A(ref structNetResource pstNetRes, string psPassword, string psUsername, int piFlags);
      [DllImport("mpr.dll")] private static extern int WNetCancelConnection2A(string psName, int piFlags, int pfForce);
      [DllImport("mpr.dll")] private static extern int WNetConnectionDialog(int phWnd, int piType);
      [DllImport("mpr.dll")] private static extern int WNetDisconnectDialog(int phWnd, int piType);
      [DllImport("mpr.dll")] private static extern int WNetRestoreConnectionW(int phWnd, string psLocalDrive);

      [StructLayout(LayoutKind.Sequential)]
      private struct structNetResource{
       public int iScope;
       public int iType;
       public int iDisplayType;
       public int iUsage;
       public string sLocalName;
       public string sRemoteName;
       public string sComment;
       public string sProvider;
      }
      
      private const int RESOURCETYPE_DISK = 0x1;
      
      //Standard 
      private const int CONNECT_INTERACTIVE = 0x00000008;
      private const int CONNECT_PROMPT = 0x00000010;
      private const int CONNECT_UPDATE_PROFILE = 0x00000001;
      //IE4+
      private const int CONNECT_REDIRECT = 0x00000080;
      //NT5 only
      private const int CONNECT_COMMANDLINE = 0x00000800;
      private const int CONNECT_CMD_SAVECRED = 0x00001000;
      
      #endregion

      #region Propertys and options
      private bool lf_SaveCredentials = false;
      /// <summary>
      /// Option to save credentials are reconnection...
      /// </summary>
      public bool SaveCredentials{
       get{return(lf_SaveCredentials);}
       set{lf_SaveCredentials=value;}
      }
      private bool lf_Persistent = false;
      /// <summary>
      /// Option to reconnect drive after log off / reboot ...
      /// </summary>
      public bool Persistent{
       get{return(lf_Persistent);}
       set{lf_Persistent=value;}
      }
      private bool lf_Force = false;
      /// <summary>
      /// Option to force connection if drive is already mapped...
      /// or force disconnection if network path is not responding...
      /// </summary>
      public bool Force{
       get{return(lf_Force);}
       set{lf_Force=value;}
      }
      private bool ls_PromptForCredentials = false;
      /// <summary>
      /// Option to prompt for user credintals when mapping a drive
      /// </summary>
      public bool PromptForCredentials{
       get{return(ls_PromptForCredentials);}
       set{ls_PromptForCredentials=value;}
      }

      private string ls_Drive = "s:";
      /// <summary>
      /// Drive to be used in mapping / unmapping...
      /// </summary>
      public string LocalDrive{
       get{return(ls_Drive);}
       set{
        if(value.Length>=1){
         ls_Drive=value.Substring(0,1)+":";
        }else{
         ls_Drive="";
        }
       }
      }
      private string ls_ShareName = "\\\\Computer\\C$";
      /// <summary>
      /// Share address to map drive to.
      /// </summary>
      public string ShareName{
       get{return(ls_ShareName);}
       set{ls_ShareName=value;}
      }
      #endregion

      #region Function mapping
      /// <summary>
      /// Map network drive
      /// </summary>
      public void MapDrive(){zMapDrive(null, null);}
      /// <summary>
      /// Map network drive (using supplied Password)
      /// </summary>
      public void MapDrive(string Password){zMapDrive(null, Password);}
      /// <summary>
      /// Map network drive (using supplied Username and Password)
      /// </summary>
      public void MapDrive(string Username, string Password){zMapDrive(Username, Password);}
      /// <summary>
      /// Unmap network drive
      /// </summary>
      public void UnMapDrive(){zUnMapDrive(this.lf_Force);}
      /// <summary>
      /// Check / restore persistent network drive
      /// </summary>
      public void RestoreDrives(){zRestoreDrive();}
      /// <summary>
      /// Display windows dialog for mapping a network drive
      /// </summary>
      public void ShowConnectDialog(Form ParentForm){zDisplayDialog(ParentForm,1);}
      /// <summary>
      /// Display windows dialog for disconnecting a network drive
      /// </summary>
      public void ShowDisconnectDialog(Form ParentForm){zDisplayDialog(ParentForm,2);}


      #endregion

      #region Core functions

      // Map network drive
      private void zMapDrive(string psUsername, string psPassword){
       //create struct data
       structNetResource stNetRes = new structNetResource();   
       stNetRes.iScope=2;
       stNetRes.iType=RESOURCETYPE_DISK;
       stNetRes.iDisplayType=3;
       stNetRes.iUsage=1;
       stNetRes.sRemoteName=ls_ShareName;
       stNetRes.sLocalName=ls_Drive;   
       //prepare params
       int iFlags=0;
       if(lf_SaveCredentials){iFlags+=CONNECT_CMD_SAVECRED;}
       if(lf_Persistent){iFlags+=CONNECT_UPDATE_PROFILE;}
       if(ls_PromptForCredentials){iFlags+=CONNECT_INTERACTIVE+CONNECT_PROMPT;}
       if(psUsername==""){psUsername=null;}
       if(psPassword==""){psPassword=null;}
       //if force, unmap ready for new connection
       if(lf_Force){try{zUnMapDrive(true);}catch{}}
       //call and return
       int i = WNetAddConnection2A(ref stNetRes, psPassword, psUsername, iFlags);   
       if(i>0){throw new System.ComponentModel.Win32Exception(i);}      
      }

      // Unmap network drive
      private void zUnMapDrive(bool pfForce){
       //call unmap and return
       int iFlags=0;
       if(lf_Persistent){iFlags+=CONNECT_UPDATE_PROFILE;}
       int i = WNetCancelConnection2A(ls_Drive, iFlags, Convert.ToInt32(pfForce));
       if(i>0){throw new System.ComponentModel.Win32Exception(i);}
      }
      // Check / Restore a network drive
      private void zRestoreDrive(){
       //call restore and return
       int i = WNetRestoreConnectionW(0, null);
       if(i>0){throw new System.ComponentModel.Win32Exception(i);}
      }
      // Display windows dialog
      private void zDisplayDialog(Form poParentForm, int piDialog)
      {
       int i = -1;
       int iHandle = 0;
       //get parent handle
       if(poParentForm!=null){
        iHandle = poParentForm.Handle.ToInt32();
       }
       //show dialog
       if(piDialog==1){
        i = WNetConnectionDialog(iHandle, RESOURCETYPE_DISK);
       }else if(piDialog==2){
        i = WNetDisconnectDialog(iHandle, RESOURCETYPE_DISK);
       }
       if(i>0){throw new System.ComponentModel.Win32Exception(i);}
       //set focus on parent form
       poParentForm.BringToFront();
      }


      #endregion

     }

    }

    terça-feira, 24 de julho de 2007 15:00
  • A depender do andar da carruagem. Pode ter havido o acesso ao servidor, antes.

    O ideal é deixar o método na classe Network, assim:


     // Map network drive
            private void zMapDrive(string psUsername, string psPassword)
            {
                try
                {

                
                //create struct data
                structNetResource stNetRes = new structNetResource();
                stNetRes.iScope = 2;
                stNetRes.iType = RESOURCETYPE_DISK;
                stNetRes.iDisplayType = 3;
                stNetRes.iUsage = 1;
                stNetRes.sRemoteName = ls_ShareName;
                //stNetRes.sLocalName = ls_Drive;
                //prepare params
                int iFlags = 0;
                if (lf_SaveCredentials) { iFlags += CONNECT_CMD_SAVECRED; }
                if (lf_Persistent) { iFlags += CONNECT_UPDATE_PROFILE; }
                if (ls_PromptForCredentials) { iFlags += CONNECT_INTERACTIVE + CONNECT_PROMPT; }
                if (psUsername == "") { psUsername = null; }
                if (psPassword == "") { psPassword = null; }
                //if force, unmap ready for new connection
                if (lf_Force) { try { zUnMapDrive(true); } catch { } }
                //call and return
                int i = WNetAddConnection2A(ref stNetRes, psPassword, psUsername, iFlags);
                if (i == 0) {
                    return;
                }
                    }catch(System.ComponentModel.Win32Exception){

                }

            }

    e a depender do seu:  

        /*mapeamento para uso dos arquivos do workbank*/
            public static void networkacessomapeamento(){
                /*Map drive using a persistent connection*/

                NetworkDrive NetDrive = new NetworkDrive();
                    
                if (NetDrive.Persistent.Equals(false))
                {
                    //NetDrive.LocalDrive         = "W:";
                    NetDrive.Force                   = true;
                    NetDrive.Persistent            = true;
                    NetDrive.SaveCredentials  = true;
                    NetDrive.ShareName          = @"\\servidor\pasta";
                    NetDrive.MapDrive(@"local\usuario do servidor", "senha do servidor");
                }
                else
               
                Thread.Sleep(2);
            }

    -- O que ocorre e que você não precisa criar o mapeamento. Porque se existir por exemplo ira enviar uma exceção para o usuário. E o mesmo sempre quer um sistema perfeito. Mesmo se ele não entender.

    E a outra ideia. E se você já fez o acesso anterior. Como ficaria ?

    Em relação as essas alterações, para mim ficaram, ok!

    Porque o usuário que fez o acesso antes ao servidor não irá receber exceção algum. Só então consultando. E o usuário que irá fazer o primeiro acesso irá receber todos os arquivos/dados existentes.




    quinta-feira, 20 de abril de 2017 17:34
  • O site para baixar :

    https://www.codeproject.com/Articles/6847/Map-Network-Drive-API

    Boa sorte e abraço !

    quinta-feira, 20 de abril de 2017 17:35