通过WMI实现远程创建共享目录，远程拷贝文件等操作

通过WMI实现了远程创建共享目录，远程拷贝文件等操作：

 代码下载

using  System;
using  System.Collections.Generic;
using  System.Text;
using  System.Management;
using  System.IO;
using  System.Diagnostics;
using  System.Threading;
using  Log;
using  System.Windows.Forms;

namespace  BankSDS
{
     ///   <summary>
     ///  注册表主键枚举
     ///   </summary>
     public   enum  RootKey :  uint
    {
        HKEY_CLASSES_ROOT  =   0x80000000 ,
        HKEY_CURRENT_USER  =   0x80000001 ,
        HKEY_LOCAL_MACHINE  =   0x80000002 ,
        HKEY_USERS  =   0x80000003 ,
        HKEY_CURRENT_CONFIG  =   0x80000005
    }

     ///   <summary>
     ///  端机信息结构
     ///   </summary>
     public   struct  ServerInfo
    {
         public   string  ServerID;
         public   string  ServerSec;
         public   string  ServerIP;
         public   string  ServerUser;
         public   string  ServerPw;
         ///   <summary>
         ///  远程推送的目标目录
         ///   </summary>
         public   string  FolderPath;
         ///   <summary>
         ///  远程共享名？
         ///   </summary>
         public   string  ShareName;
         ///   <summary>
         ///  远程推送的说明
         ///   </summary>
         public   string  Description;
         ///   <summary>
         ///  远程推送的文件集合
         ///   </summary>
         public   string  [] strSource;
         ///   <summary>
         ///  推送成功后，要设置的注册表自动启动项名称
         ///   </summary>
         public   string  strTarget;
         ///   <summary>
         ///  传送类型
         ///   </summary>
         public   int  transType;
         public   bool  Result;
    }

     ///   <summary>
     ///  用于WMI连接的用户信息结构
     ///   </summary>
     public   struct  UserInfo
    {
         public   string  UserName;
         public   string  UserPW;
         public   bool  IsEnable;
    }

     ///   <summary>
     ///  WMI基本封装
     ///   </summary>
     public   class  WmiShareFunction
    {
         public   static  CLog Wmilog  =   new  CLog(Application.StartupPath  +   @" \\AppLogs\\Wmi.log " );

         ///   <summary>
         ///  创建远程目录
         ///   </summary>
         ///   <param name="scope"> ManagementScope Instance </param>
         ///   <param name="DirectoryName"> 要建立的目录名 </param>
         ///   <param name="CurrentDirectory"> 根目录所在位置，缺省为C:\ </param>
         ///   <returns> 0表示建立成功，-1表示建立失败 </returns>
         public   static   int  CreateRemoteDirectory(ManagementScope scope,  string  DirectoryName,  string  CurrentDirectory)
        {
             try
            {
                 string  currentDirectory  =  CurrentDirectory;
                 if  (String.IsNullOrEmpty(CurrentDirectory))
                {
                    currentDirectory  =   @" C:\ " ;
                }
                ObjectGetOptions objectGetOptions  =   new  ObjectGetOptions( null , System.TimeSpan.MaxValue,  true );
                ManagementPath managementPath  =   new  ManagementPath( " Win32_Process " );

                ManagementClass processBatch  =   new  ManagementClass(scope, managementPath, objectGetOptions);
                ManagementBaseObject inParams  =  processBatch.GetMethodParameters( " Create " );

                inParams[ " CommandLine " ]  =   @" cmd /CMd  "   +  DirectoryName;
                inParams[ " CurrentDirectory " ]  =  currentDirectory;

                ManagementBaseObject outParams  =   null ;
                outParams  =  processBatch.InvokeMethod( " Create " , inParams,  null );

                Wmilog.WriteToLog( " Excute CreateRemoteDirectory: "   +  outParams.ToString());
            }
             catch  (Exception ex)
            {
                Wmilog.WriteToLog( " in CreateRemoteDirectory Exception: "   +  ex.Message);
                 return   - 1 ;
            }
            Wmilog.WriteToLog( " 建远程目录成功! " );
             return   0 ;
        }

         ///   <summary>
         ///  在远程目标机器上创建一个注册表主键
         ///   </summary>
         ///   <param name="connectionScope"> ManagementScope </param>
         ///   <param name="machineName"> 目标机器IP </param>
         ///   <param name="BaseKey"> 注册表分支名 </param>
         ///   <param name="key"> 主键名称 </param>
         ///   <returns> 创建成功则返回0 </returns>
         public   static   int  CreateRemoteKey(ManagementScope connectionScope,
                                   string  machineName,
                                  RootKey BaseKey,
                                   string  key)
        {
             try
            {
                ObjectGetOptions objectGetOptions  =   new  ObjectGetOptions( null , System.TimeSpan.MaxValue,  true );
                connectionScope.Path  =   new  ManagementPath( @" \\ "   +  machineName  +   @" \root\DEFAULT:StdRegProv " );
                connectionScope.Connect();
                ManagementClass registryTask  =   new  ManagementClass(connectionScope,
                                new  ManagementPath( @" DEFAULT:StdRegProv " ), objectGetOptions);
                ManagementBaseObject methodParams  =  registryTask.GetMethodParameters( " CreateKey " );

                methodParams[ " hDefKey " ]  =  BaseKey;
                methodParams[ " sSubKeyName " ]  =  key;

                ManagementBaseObject exitCode  =  registryTask.InvokeMethod( " CreateKey " ,
                                                                      methodParams,  null );

                Wmilog.WriteToLog( " in CreateRemoteKey: "   +  exitCode.ToString());
            }
             catch  (ManagementException e)
            {
                Wmilog.WriteToLog( " in CreateRemoteKey(ManagementException): "   +  e.Message);
                 return   - 1 ;
            }
            Wmilog.WriteToLog( " 注册表主键创建成功！ " );
             return   0 ;
        }

         ///   <summary>
         ///  在远程目标机器上创建一个注册表键值
         ///   </summary>
         ///   <param name="connectionScope"> ManagementScope </param>
         ///   <param name="machineName"> 目标机器IP </param>
         ///   <param name="BaseKey"> 注册表分支名 </param>
         ///   <param name="key"> 主键名称 </param>
         ///   <param name="valueName"> 键值名称 </param>
         ///   <param name="value"> 键值 </param>
         ///   <returns> 创建成功则返回0 </returns>
         public   static   int  CreateRemoteValue(ManagementScope connectionScope,
                                     string  machineName,
                                    RootKey BaseKey,
                                     string  key,
                                     string  valueName,
                                     string  value)
        {
             try
            {
                ObjectGetOptions objectGetOptions  =   new  ObjectGetOptions( null , System.TimeSpan.MaxValue,  true );
                connectionScope.Path  =   new  ManagementPath( @" \\ "   +  machineName  +   @" \root\DEFAULT:StdRegProv " );
                connectionScope.Connect();
                ManagementClass registryTask  =   new  ManagementClass(connectionScope,
                                new  ManagementPath( @" DEFAULT:StdRegProv " ), objectGetOptions);
                ManagementBaseObject methodParams  =  registryTask.GetMethodParameters( " SetStringValue " );

                methodParams[ " hDefKey " ]  =  BaseKey;
                methodParams[ " sSubKeyName " ]  =  key;
                methodParams[ " sValue " ]  =  value;
                methodParams[ " sValueName " ]  =  valueName;

                ManagementBaseObject exitCode  =  registryTask.InvokeMethod( " SetStringValue " ,
                                                                         methodParams,  null );

                Wmilog.WriteToLog( " in CreateRemoteValue: "   +  exitCode.ToString());
            }
             catch  (ManagementException e)
            {
                Wmilog.WriteToLog( " in CreateRemoteValue(ManagementException): "   +  e.Message);
                 return   - 1 ;
            }
            Wmilog.WriteToLog( " 注册表键值写入成功！ " );
             return   0 ;
        }

         ///   <summary>
         ///  执行远程文件/目录推送
         ///   </summary>
         ///   <param name="Server"> 目标地址 </param>
         ///   <param name="Username"> 目标设备登录用户 </param>
         ///   <param name="Password"> 目标设备登录PWD </param>
         ///   <param name="FolderPath"> 远程目标目录 </param>
         ///   <param name="ShareName"> 网络共享名 </param>
         ///   <param name="Description"> 网络共享描述 </param>
         ///   <param name="reginfo"> 推送成功后，可以设置的注册表项名称 </param>
         ///   <param name="strSources"> 要推送的源文件信息 </param>
         ///   <param name="iType"> 推送类型;0表示推送文件，1表示推送目录 </param>
         ///   <returns> 推送成功则返回true </returns>
         public   static   bool  WmiFileCopyToRemote( string  Server,
                       string  Username,
                       string  Password,
                       string  FolderPath,
                       string  ShareName,
                       string  Description,
                       string  reginfo,
                       string [] strSources,
                       int  iType
                     )
        {
             #region  远程共享目录组合

             // 远程共享名
            StringBuilder TargetDir  =   new  StringBuilder();
            TargetDir.Append( @" \\ " );
            TargetDir.Append(Server);
            TargetDir.Append( " \\ " );
            TargetDir.Append(ShareName);
            TargetDir.Append( " \\ " );

             #endregion

             #region  注册表值组合

            StringBuilder KeyValue  =   new  StringBuilder();
            KeyValue.Append(FolderPath);
            KeyValue.Append( " \\ " );

             #endregion

             #region  WMI连接设置

            ConnectionOptions options  =   new  ConnectionOptions();
            options.Username  =  Username;
            options.Password  =  Password;

             // options.Authority = "ntdlmdomain:DOMAIN";
            options.Impersonation  =  ImpersonationLevel.Impersonate;
            options.EnablePrivileges  =   true ;
             // options.Authentication = AuthenticationLevel.Connect;
             // options.Authority
            ManagementScope scope  =   new  ManagementScope(
                     " \\\\ "   +  Server  +   " \\root\\cimv2 " ,
                    options);
             #endregion

             try
            {
                Wmilog.WriteToLog( " 开始WMI连接......  " );
                scope.Connect();
                 if  (scope.IsConnected)
                {
                    Wmilog.WriteToLog( " WMI连接成功...... " );

                    Wmilog.WriteToLog( " 建远程目录开始...... " );
                    CreateRemoteDirectory(scope, FolderPath,  "" );
                    Wmilog.WriteToLog( " 建远程目录结束...... " );

                    Wmilog.WriteToLog( " 建远程共享目录开始...... " );
                    CreateShareNetFolder(scope, FolderPath, ShareName, Description);
                    Wmilog.WriteToLog( " 建远程共享目录结束...... " );

                    Wmilog.WriteToLog( " 连接远程共享开始...... " );
                    CreateShareNetConnect(Server, ShareName, Username, Password);
                    Wmilog.WriteToLog( " 连接远程共享结束...... " );

                     // 通过远程共享名，向远程共享目录中拷贝文件
                     if  (iType  ==   0 )
                    {
                         // 文件拷贝
                        Wmilog.WriteToLog( " in CopyFiles: "   +   " Start " .ToString());
                        System.Diagnostics.Debug.WriteLine( " in CopyFiles: "   +   " Start " .ToString());
                         foreach  ( string  filename  in  strSources)
                        {
                             if  ( ! String.IsNullOrEmpty(filename))
                            {
                                FileInfo fileinfo  =   new  FileInfo(filename);
                                File.Copy(filename, TargetDir  +  fileinfo.Name,  true );
                                System.Diagnostics.Debug.WriteLine(filename  +   "   "   +  TargetDir  +  fileinfo.Name);

                            }
                        }
                        KeyValue.Append(reginfo);
                        Wmilog.WriteToLog( " in CopyFiles: "   +   " End " .ToString());
                        System.Diagnostics.Debug.WriteLine( " in CopyFiles: "   +   " End " .ToString());
                    }
                     else   if  (iType  ==   1 )
                    {
                         // 目录拷贝
                        DirectoryInfo DirInfo  =   new  DirectoryInfo(strSources[ 0 ]);
                        KeyValue.Append(DirInfo.Name);
                        KeyValue.Append( " \\ " );
                        KeyValue.Append(reginfo);
                        Wmilog.WriteToLog( " in CopyDirectory: "   +   " Start " .ToString());
                        System.Diagnostics.Debug.WriteLine( " in CopyDirectory: "   +   " Start " .ToString());
                        CopyDirectory(strSources[ 0 ], TargetDir  +  DirInfo.Name);
                        Wmilog.WriteToLog( " in CopyDirectory: "   +   " End " .ToString());
                        System.Diagnostics.Debug.WriteLine( " in CopyDirectory: "   +   " End " .ToString());
                    }

                    Wmilog.WriteToLog( " 断开远程共享开始 " );
                    RemoveShareNetConnect(Server, ShareName, Username, Password);
                    Wmilog.WriteToLog( " 断开远程共享结束 " );

                    Wmilog.WriteToLog( " 删除远程共享目录开始 " );
                    RemoveShareNetFolder(scope, ShareName);
                    Wmilog.WriteToLog( " 删除远程共享目录结束 " );

                     if  ( ! String.IsNullOrEmpty(reginfo))
                    {
                        Wmilog.WriteToLog( " 查找或建立注册表主键开始 " );
                        CreateRemoteKey(scope, Server, RootKey.HKEY_LOCAL_MACHINE,  @" Software\Microsoft\Windows\CurrentVersion\Run " );
                        Wmilog.WriteToLog( " 查找或建立注册表主键结束 " );

                        Wmilog.WriteToLog( " 设置注册表值开始 " );
                        CreateRemoteValue(scope, Server, RootKey.HKEY_LOCAL_MACHINE,  @" Software\Microsoft\Windows\CurrentVersion\Run " , reginfo, KeyValue.ToString());
                        Wmilog.WriteToLog( " 设置注册表值结 " );
                    }
                }
            }
             catch  (Exception e)
            {
                Wmilog.WriteToLog( " WMI连接失败(Exception):  "   +  e.Message);
                System.Diagnostics.Debug.WriteLine( " in WmiFileCopyToRemote Exception: "   +  e.Message);
                 return   false ;
            }
            Wmilog.WriteToLog( " WMI操作成功结束  " );

             return   true ;
        }

         ///   <summary>
         ///  创建远程共享目录
         ///   </summary>
         ///   <param name="scope"> ManagementScope </param>
         ///   <param name="FolderPath"> 要共享的目录路径 </param>
         ///   <param name="ShareName"> 共享名 </param>
         ///   <param name="Description"> 网络共享文件夹的描述 </param>
         ///   <returns> 0表示创建成功，-1表示创建失败 </returns>
         public   static   int  CreateShareNetFolder(ManagementScope scope,  string  FolderPath,  string  ShareName,  string  Description)
        {
             try
            {
                 // 创建一个ManagementClass对像
                ManagementClass managementClass  =   new  ManagementClass(scope,  new  ManagementPath( " Win32_Share " ),  null );

                 // 创建ManagementBaseObject的输入和输出参数
                ManagementBaseObject inParams  =  managementClass.GetMethodParameters( " Create " );
                ManagementBaseObject outParams;

                 // 设置输入参数
                inParams[ " Description " ]  =  Description;
                inParams[ " Name " ]  =  ShareName;
                inParams[ " Path " ]  =  FolderPath;
                inParams[ " Type " ]  =   0x0 ; // DISK_DRIVE

                 // 其它类型
                 // DISK_DRIVE=0x0
                 // PRINT_QUEUE=0x1
                 // DEVICE = 0x2
                 // IPC = 0x3
                 // DISK_DRIVE_ADMIN = 0x80000000
                 // PRINT_QUEUE_ADMIN=0x80000001
                 // DEVICE_ADMIN=0x80000002
                 // IPC_ADMIN=0x80000003
                 // inParams["MaximunAllowed"] = intMaxConnectionsNum;

                 // 调用方法ManagementClass对像
                outParams  =  managementClass.InvokeMethod( " Create " , inParams,  null );

                Wmilog.WriteToLog( " Excute ShareNetFolder Result: "   +  outParams.ToString());
                 // 检测方法是否调用成功
                 if  (( uint )(outParams.Properties[ " RetrunValue " ].Value)  !=   0 )
                {
                     throw   new  Exception( " Unable to create net share directiory! " );
                }
            }
             catch  (Exception ex)
            {
                Wmilog.WriteToLog( " 创建远程共享目录失败: "   +  ex.Message);
                 return   - 1 ;
            }
            Wmilog.WriteToLog( " 创建远程共享目录成功！ " );
             return   0 ;
        }

         ///   <summary>
         ///  移除远程共享目录
         ///   </summary>
         ///   <param name="scope"> ManagementScope </param>
         ///   <param name="ShareName"> 共享名 </param>
         ///   <returns> 移除成功则返回0 </returns>
         public   static   int  RemoveShareNetFolder(ManagementScope scope,  string  ShareName)
        {
             try
            {
                 // SelectQuery selectQuery = new SelectQuery("Select * from Win32_Share Where Name = '" + ShareName + "'");
                ObjectQuery selectQuery  =   new  ObjectQuery( " Select * from Win32_Share Where Name = ' "   +  ShareName  +   " ' " );
                ManagementObjectSearcher searcher  =   new  ManagementObjectSearcher(scope, selectQuery);
                 foreach  (ManagementObject mo  in  searcher.Get())
                {
                    mo.InvokeMethod( " Delete " ,  null ,  null );
                }
                System.Diagnostics.Debug.WriteLine( " in CancelShareNetFolder: "   +  ShareName);
            }
             catch  (ManagementException me)
            {
                Wmilog.WriteToLog( " 移除远程共享目录失败(ManagementException): "   +  me.Message);
                 return   - 1 ;
            }
             catch  (Exception e)
            {
                Wmilog.WriteToLog( " 移除远程共享目录失败(Exception): "   +  e.Message);
                 return   - 1 ;
            }

            Wmilog.WriteToLog( " 移除远程共享目录成功！ " );
             return   0 ;
        }

         ///   <summary>
         ///  使用net use命令远程连接目标机器，拷贝文件
         ///   </summary>
         ///   <param name="strSource"> 源文件 </param>
         ///   <param name="strTarget"> 目标文件 </param>
         ///   <param name="Server"> 目标ip </param>
         ///   <param name="ShareName"> 远程共享名 </param>
         ///   <param name="Username"> 远程登录用户 </param>
         ///   <param name="Password"> 远程登录密码 </param>
         ///   <returns> 拷贝成功则返回0 </returns>
         public   static   int  FileCopy( string  strSource,  string  strTarget,  string  Server,  string  ShareName,  string  Username,  string  Password)
        {
            Process process  =   new  Process();
             try
            {

                process.StartInfo.FileName  =   " net.exe " ;
                process.StartInfo.Arguments  =   @" use \\ "   +  Server  +   @" \ "   +  ShareName  +   "  \ ""  + Password +  " \ "  /user:\ ""  + Username +  " \ "   " ;
                process.StartInfo.CreateNoWindow  =   true ;
                process.StartInfo.UseShellExecute  =   false ;
                process.Start();
                System.Diagnostics.Debug.WriteLine(process.StartInfo.FileName  +   "   "   +  process.StartInfo.Arguments);
                process.WaitForExit();
                System.Diagnostics.Debug.WriteLine( " Start Copy File..... " );
                File.Copy(strSource, strTarget,  true );
                System.Diagnostics.Debug.WriteLine( " End Copy File..... " );
                process.StartInfo.Arguments  =   @" use \\ "   +  Server  +   @" \ "   +  ShareName  +   "  /delete " ;
                process.Start();
                process.Close();
            }
             catch  (IOException ex)
            {
                System.Diagnostics.Debug.WriteLine( " in FileCopy IOException: "   +  ex.Message);
                 return   - 1 ;
            }
             catch  (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine( " in FileCopy Exception: "   +  ex.Message);
                 return   - 1 ;
            }
             finally
            {
                process.Dispose();
            }
             return   0 ;
        }
        
         ///   <summary>
         ///  通过远程共享名，递归拷贝指定目录下的所有信息到目标目录
         ///   </summary>
         ///   <param name="sPath"> 源目录 </param>
         ///   <param name="dPath"> 目的目录 </param>
         public   static   void  CopyDirectory( string  sPath,  string  dPath)
        {
             string [] directories  =  System.IO.Directory.GetDirectories(sPath);
             if  ( ! System.IO.Directory.Exists(dPath))
                System.IO.Directory.CreateDirectory(dPath);
            System.IO.DirectoryInfo dir  =   new  System.IO.DirectoryInfo(sPath);
            System.IO.DirectoryInfo[] dirs  =  dir.GetDirectories();
            CopyFile(dir, dPath);

             if  (dirs.Length  >   0 )
            {
                 foreach  (System.IO.DirectoryInfo temDirectoryInfo  in  dirs)
                {
                     string  sourceDirectoryFullName  =  temDirectoryInfo.FullName;
                     string  destDirectoryFullName  =  sourceDirectoryFullName.Replace(sPath, dPath);
                     if  ( ! System.IO.Directory.Exists(destDirectoryFullName))
                    {
                        System.IO.Directory.CreateDirectory(destDirectoryFullName);
                    }
                    CopyFile(temDirectoryInfo, destDirectoryFullName);
                    CopyDirectory(sourceDirectoryFullName, destDirectoryFullName);
                }
            }
        }

         ///   <summary>
         ///  通过远程共享名，拷贝指定目录下的所有文件到目标目录
         ///   </summary>
         ///   <param name="path"> 源路径 </param>
         ///   <param name="desPath"> 目的路径（\\targetServer\\shareName\\DirectoryPath） </param>
         public   static   void  CopyFile(System.IO.DirectoryInfo path,  string  desPath)
        {
             string  sourcePath  =  path.FullName;
            System.IO.FileInfo[] files  =  path.GetFiles();
             foreach  (System.IO.FileInfo file  in  files)
            {
                 string  sourceFileFullName  =  file.FullName;
                 string  destFileFullName  =  sourceFileFullName.Replace(sourcePath, desPath);
                file.CopyTo(destFileFullName,  true );
            }
        }

         ///   <summary>
         ///  用net use命令连接到远程共享目录上，创建网络共享连接
         ///   </summary>
         ///   <param name="Server"> 目标ip </param>
         ///   <param name="ShareName"> 远程共享名 </param>
         ///   <param name="Username"> 远程登录用户 </param>
         ///   <param name="Password"> 远程登录密码 </param>
         public   static   void  CreateShareNetConnect( string  Server,  string  ShareName,  string  Username,  string  Password)
        {
            Process process  =   new  Process();
            process.StartInfo.FileName  =   " net.exe " ;
            process.StartInfo.Arguments  =   @" use \\ "   +  Server  +   @" \ "   +  ShareName  +   "  \ ""  + Password +  " \ "  /user:\ ""  + Username +  " \ "   " ;
            process.StartInfo.CreateNoWindow  =   true ;
            process.StartInfo.UseShellExecute  =   false ;
            process.Start();
            process.WaitForExit();
            process.Close();
            process.Dispose();
        }

         ///   <summary>
         ///  用net use delete命令移除网络共享连接
         ///   </summary>
         ///   <param name="Server"> 目标ip </param>
         ///   <param name="ShareName"> 远程共享名 </param>
         ///   <param name="Username"> 远程登录用户 </param>
         ///   <param name="Password"> 远程登录密码 </param>
         public   static   void  RemoveShareNetConnect( string  Server,  string  ShareName,  string  Username,  string  Password)
        {
             // System.Diagnostics.Process.Start("net.exe", @"use \\" + Server + @"\" + ShareName + " \"" + Password + "\" /user:\"" + Username + "\" ");
            Process process  =   new  Process();
            process.StartInfo.FileName  =   " net.exe " ;
            process.StartInfo.Arguments  =   @" use \\ "   +  Server  +   @" \ "   +  ShareName  +   "  /delete " ;
            process.StartInfo.CreateNoWindow  =   true ;
            process.StartInfo.UseShellExecute  =   false ;
            process.Start();
            process.WaitForExit();
            process.Close();
            process.Dispose();

        }
    }
}

 

 

 

转载于:https://www.cnblogs.com/ajiefj/archive/2010/05/11/1732963.html