C# 文件夹共享和权限设置

2014-06-04 03:41:39 546 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

C#读写共享文件夹该试验分以下步骤： 1、在服务器设置一个共享文件夹，在这里我的服务器ip地址是10.80.88.180，共享文件夹名字是test，test里面有两个文件：good.txt和bad.txt，访问权限，用户名是admin，密码是admin。 2、新建一个webapplication项目，在前台页面加一个listbox，ID是ListBox1. 3、添加后台代码如下：其中包含的功能是读阅读详情

我想实现：文件夹共享后给文件夹添加用户、并给他添加权限查看或者更改有谁做过啊能给我发个源代码吗？网上好多帖子页看了有点晕。我用的是 C# web

...全文

C# 服务器间读取上传图片实现由于项目使用了负载，所以有这样的需求，需要把文件保存到同一个服务器下，然后去指定的服务器读取文件。我经过了一些搜索，找到了2个办法来实现。一种是使用共享文件夹的方式，还有一种是使用FTP协议去传输文件。下面先记录下使用共享文件夹的方式。首先，在指定服务器下，创建共享文件，名称为Share，把它共享给所有人，读写权限。然后，代码如下： using System; using Sys 阅读详情

li_east_fai

C# 111,128 成员 642,536 内容

+ 关注 + 加入社区

切换为时间正序

li_east_fai 2014-06-05

打赏
举报

非常感谢。

呱呱_瓜瓜 2014-06-04

打赏
举报

以上就是全部代码了

呱呱_瓜瓜 2014-06-04

打赏
举报


public enum MethodStatus : uint
    {
        Success = 0, 	//Success
        AccessDenied = 2, 	//Access denied
        UnknownFailure = 8, 	//Unknown failure
        InvalidName = 9, 	//Invalid name
        InvalidLevel = 10, 	//Invalid level
        InvalidParameter = 21, 	//Invalid parameter
        DuplicateShare = 22, 	//Duplicate share
        RedirectedPath = 23, 	//Redirected path
        UnknownDevice = 24, 	//Unknown device or directory
        NetNameNotFound = 25 	//Net name not found
    }

    public enum ShareType : uint
    {
        DiskDrive = 0x0, 	//Disk Drive
        PrintQueue = 0x1, 	//Print Queue
        Device = 0x2, 	//Device
        IPC = 0x3, 	//IPC
        DiskDriveAdmin = 0x80000000, 	//Disk Drive Admin
        PrintQueueAdmin = 0x80000001, 	//Print Queue Admin
        DeviceAdmin = 0x80000002, 	//Device Admin
        IpcAdmin = 0x80000003 	//IPC Admin
    }
    public enum AccessPrivileges : uint
    {
        /// <summary>
        /// 列出文件夹/读取数据
        /// </summary>
        FILE_READ_DATA = 0x00000001,
        /// <summary>
        /// 创建文件/写入数据
        /// </summary>
        FILE_WRITE_DATA = 0x00000002,
        /// <summary>
        /// 创建文件夹/附加数据
        /// </summary>
        FILE_APPEND_DATA = 0x00000004,
        /// <summary>
        /// 读取扩展属性
        /// </summary>
        FILE_READ_EA = 0x00000008,
        /// <summary>
        /// 写入扩展属性
        /// </summary>
        FILE_WRITE_EA = 0x00000010,
        /// <summary>
        /// 遍历文件夹/执行文件
        /// </summary>
        FILE_EXECUTE = 0x00000020,
        /// <summary>
        /// 删除子文件夹及文件
        /// </summary>
        FILE_DELETE_CHILD = 0x00000040,
        /// <summary>
        /// 读取属性
        /// </summary>
        FILE_READ_ATTRIBUTES = 0x00000080,
        /// <summary>
        /// 写入属性
        /// </summary>
        FILE_WRITE_ATTRIBUTES = 0x00000100,
        /// <summary>
        /// 删除
        /// </summary>
        DELETE = 0x00010000,
        /// <summary>
        /// 读取权限
        /// </summary>
        READ_CONTROL = 0x00020000,
        /// <summary>
        /// 更改权限
        /// </summary>
        WRITE_DAC = 0x00040000,
        /// <summary>
        /// 取得所有权
        /// </summary>
        WRITE_OWNER = 0x00080000,
        /// <summary>
        /// 无任何权限
        /// </summary>
        SYNCHRONIZE = 0x00100000,
        /// <summary>
        /// 所有权限
        /// </summary>
        Full = AccessPrivileges.DELETE | AccessPrivileges.FILE_APPEND_DATA | AccessPrivileges.FILE_DELETE_CHILD | AccessPrivileges.FILE_EXECUTE
        | AccessPrivileges.FILE_READ_ATTRIBUTES | AccessPrivileges.FILE_READ_DATA | AccessPrivileges.FILE_READ_EA | AccessPrivileges.FILE_WRITE_ATTRIBUTES
        | AccessPrivileges.FILE_WRITE_DATA | AccessPrivileges.FILE_WRITE_EA | AccessPrivileges.READ_CONTROL | AccessPrivileges.SYNCHRONIZE
        | AccessPrivileges.WRITE_DAC | AccessPrivileges.WRITE_OWNER
    }

    enum AceFlags : uint
    {
        NonInheritAce = 0,
        ObjectInheritAce = 1,
        ContainerInheritAce = 2,
        NoPropagateInheritAce = 4,
        InheritOnlyAce = 8,
        InheritedAce = 16
    }

    [Flags]
    enum AceType : uint
    {
        AccessAllowed = 0,
        AccessDenied = 1,
        Audit = 2
    }
 public class UserPrivileges
    {
        public string UserAccount { get; set; }
        public List<String> Privileges { get; set; }
        public string Domain { get; set; }
        public object ObjPrivileges
        {
            get;
            set;
        }
    }

呱呱_瓜瓜 2014-06-04

打赏
举报

以前做过类似的也是web设置文件夹共享权限的，仅供参考


public class ShareHelper
    {
        static string[] filedesc = {"FILE_READ_DATA", "FILE_WRITE_DATA", "FILE_APPEND_DATA", "FILE_READ_EA",

"FILE_WRITE_EA", "FILE_EXECUTE", "FILE_DELETE_CHILD", "FILE_READ_ATTRIBUTES",

"FILE_WRITE_ATTRIBUTES", " ", " ", " ",

" ", " ", " ", " ",

"DELETE ", "READ_CONTROL", "WRITE_DAC", "WRITE_OWNER",

"SYNCHRONIZE ", " ", " "," ",

"ACCESS_SYSTEM_SECURITY", "MAXIMUM_ALLOWED", " "," ",

"GENERIC_ALL", "GENERIC_EXECUTE", "GENERIC_WRITE","GENERIC_READ"};

        private ManagementObject mWinShareObject;

        private ShareHelper(ManagementObject obj) { mWinShareObject = obj; }

        #region Wrap Win32_Share properties
        public uint AccessMask
        {
            get { return Convert.ToUInt32(mWinShareObject["AccessMask"]); }
        }

        public bool AllowMaximum
        {
            get { return Convert.ToBoolean(mWinShareObject["AllowMaximum"]); }
        }

        public string Caption
        {
            get { return Convert.ToString(mWinShareObject["Caption"]); }
        }

        public string Description
        {
            get { return Convert.ToString(mWinShareObject["Description"]); }
        }

        public DateTime InstallDate
        {
            get { return Convert.ToDateTime(mWinShareObject["InstallDate"]); }
        }

        public uint MaximumAllowed
        {
            get { return Convert.ToUInt32(mWinShareObject["MaximumAllowed"]); }
        }

        public string Name
        {
            get { return Convert.ToString(mWinShareObject["Name"]); }
        }

        public string Path
        {
            get { return Convert.ToString(mWinShareObject["Path"]); }
        }

        public string Status
        {
            get { return Convert.ToString(mWinShareObject["Status"]); }
        }

        public ShareType Type
        {
            get { return (ShareType)Convert.ToUInt32(mWinShareObject["Type"]); }
        }
        #endregion

        #region Wrap Methods
        /// <summary>
        /// 删除共享
        /// </summary>
        /// <returns></returns>
        public MethodStatus Delete()
        {
            object result = mWinShareObject.InvokeMethod("Delete", new object[] { });
            uint r = Convert.ToUInt32(result);

            return (MethodStatus)r;
        }

        /// <summary>
        /// 创建共享
        /// </summary>
        /// <param name="path"></param>
        /// <param name="name"></param>
        /// <param name="type"></param>
        /// <param name="maximumAllowed"></param>
        /// <param name="description"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        public static MethodStatus Create(string path, string name, ShareType type, uint maximumAllowed, string description, string password)
        {
            ManagementClass mc = new ManagementClass("Win32_Share");
            object[] parameters = new object[] { path, name, (uint)type, maximumAllowed, description, password, null };

            object result = mc.InvokeMethod("Create", parameters);
            uint r = Convert.ToUInt32(result);

            return (MethodStatus)r;
        }

        #endregion

        public static IList<ShareHelper> GetAllShares()
        {
            IList<ShareHelper> result = new List<ShareHelper>();
            ManagementClass mc = new ManagementClass("Win32_Share");
            ManagementObjectCollection moc = mc.GetInstances();

            foreach (ManagementObject mo in moc)
            {
                ShareHelper share = new ShareHelper(mo);
                result.Add(share);
            }

            return result;
        }

        public static ShareHelper GetNamedShare(string name)
        {
            // Not a very efficient implementation obviously, but heck... This is sample code. ;)
            IList<ShareHelper> shares = GetAllShares();

            foreach (ShareHelper s in shares)
                if (s.Name == name)
                    return s;

            return null;
        }

        public static MethodStatus SetPrivileges(string path, List<UserPrivileges> listPrivilege)
        {
            ManagementObject mo = new ManagementObject(string.Format("Win32_LogicalFileSecuritySetting.Path='{0}'", path));
            ManagementBaseObject outParams = mo.InvokeMethod("GetSecurityDescriptor", null, null);

            if ((uint)outParams.Properties["ReturnValue"].Value != 0)
            {
                return MethodStatus.NetNameNotFound;
            }
            ManagementBaseObject Descriptor = (ManagementBaseObject)outParams.Properties["Descriptor"].Value;

            List<ManagementBaseObject> newDacl = new List<ManagementBaseObject>();

            foreach (UserPrivileges up in listPrivilege)
            {

                ManagementClass trustee = new ManagementClass("win32_trustee");
                trustee.Properties["Name"].Value = up.UserAccount;
                trustee.Properties["Domain"].Value = null;


                ManagementClass ace = new ManagementClass("win32_ace");
                ace.Properties["AccessMask"].Value = up.ObjPrivileges; //AccessPrivileges.FileReadData | AccessPrivileges.FileReadAttributes | AccessPrivileges.FileReadEA
                //| AccessPrivileges.ReadControl | AccessPrivileges.FileExecute;
                ace.Properties["AceFlags"].Value = AceFlags.ObjectInheritAce | AceFlags.ContainerInheritAce | AceFlags.NoPropagateInheritAce;
                ace.Properties["AceType"].Value = AceType.AccessAllowed;
                ace.Properties["Trustee"].Value = trustee;
                newDacl.Add(ace);
            }
            ManagementBaseObject inParams = mo.GetMethodParameters("SetSecurityDescriptor");
            Descriptor.Properties["Dacl"].Value = newDacl.ToArray();


            inParams["Descriptor"] = Descriptor;
            ManagementBaseObject ret = mo.InvokeMethod("SetSecurityDescriptor", inParams, null);

            uint returnValue = (uint)ret.Properties["ReturnValue"].Value;
            return (MethodStatus)returnValue;
        }

        public static List<UserPrivileges> GetPrivileges(string path)
        {
            List<UserPrivileges> list = new List<UserPrivileges>();
            ManagementPath mPath = new ManagementPath();
            mPath.Server = ".";
            mPath.NamespacePath = @"root\cimv2";
            mPath.RelativePath = @"Win32_LogicalFileSecuritySetting.Path='" + path + "'"; // using tmp as folder name

            ManagementObject lfs = new ManagementObject(mPath);

            ManagementBaseObject outParams = lfs.InvokeMethod("GetSecurityDescriptor", null, null);
            if (((uint)(outParams.Properties["ReturnValue"].Value)) == 0)
            {

                ManagementBaseObject Descriptor = ((ManagementBaseObject)(outParams.Properties["Descriptor"].Value));

                ManagementBaseObject[] DaclObject = ((ManagementBaseObject[])(Descriptor.Properties["Dacl"].Value));

                foreach (ManagementBaseObject mbo in DaclObject)
                {
                    UserPrivileges up = new UserPrivileges();
                    ManagementBaseObject Trustee = ((ManagementBaseObject)(mbo["Trustee"]));
                    up.Domain = Trustee.Properties["Domain"].Value == null ? "" : Trustee.Properties["Domain"].Value.ToString();
                    up.UserAccount = Trustee.Properties["Name"].Value.ToString();


                    UInt32 mask = (UInt32)mbo["AccessMask"];

                    int[] m = { (int)mask };

                    BitArray ba = new BitArray(m);

                    int i = 0;

                    IEnumerator baEnum = ba.GetEnumerator();
                    up.Privileges = new List<string>();
                    while (baEnum.MoveNext())
                    {

                        if ((bool)baEnum.Current)

                            up.Privileges.Add(filedesc[i].Trim());

                        i++;

                    }
                    list.Add(up);
                }



            }

            List<UserPrivileges> listNew = new List<UserPrivileges>();
            foreach (var up in list)
            {
                UserPrivileges upNew=listNew.Where(x => x.UserAccount == up.UserAccount).FirstOrDefault();
                if (upNew!=null)
                {
                    upNew.Privileges.AddRange(up.Privileges);
                    upNew.Privileges=upNew.Privileges.Distinct().ToList();
                }
                else
                {
                    listNew.Add(up);
                }
            }
            return listNew; ;
        }
    }

C# 文件夹共享和权限设置

相关推荐