Net1.1没有专门封装好的WIN32管理类（2.0就方便多了），分享一下目录共享及权限的方法（网上找了许多都是文不对题的）
权限定义：
[Flags]
public enum AccessPrivileges : uint{
FILE_READ_DATA = 0x00000001,
FILE_WRITE_DATA = 0x00000002,
FILE_APPEND_DATA = 0x00000004,
FILE_READ_EA = 0x00000008,
FILE_WRITE_EA = 0x00000010,
FILE_EXECUTE = 0x00000020,
FILE_DELETE_CHILD = 0x00000040,
FILE_READ_ATTRIBUTES = 0x00000080,
FILE_WRITE_ATTRIBUTES = 0x00000100,
DELETE = 0x00010000,
READ_CONTROL = 0x00020000,
WRITE_DAC = 0x00040000,
WRITE_OWNER = 0x00080000,
SYNCHRONIZE = 0x00100000,
ACCESS_SYSTEM_SECURITY = 0x01000000,
MAXIMUM_ALLOWED = 0x02000000,
GENERIC_ALL = 0x10000000,
GENERIC_EXECUTE= 0x20000000,
GENERIC_WRITE = 0x40000000,
GENERIC_READ = 0x80000000
}
[Flags]
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
}
流程：
//设置Everyone用户，可以选择其他用户或新建用户
ManagementClass trustee = new ManagementClass("Win32_Trustee");
trustee.Properties["Name"].Value = "Everyone";
trustee.Properties["Domain"].Value = null;
trustee.Properties["SID"].Value = new byte[]{1,1,0,0,0,0,0,1,0,0,0,0};
//设置只读/运行权限
ManagementClass ace = new ManagementClass("Win32_ACE");
ace.Properties["AccessMask"].Value = AccessPrivileges.GENERIC_READ
| AccessPrivileges.FILE_READ_DATA | AccessPrivileges.FILE_READ_ATTRIBUTES | AccessPrivileges.FILE_READ_EA
| AccessPrivileges.READ_CONTROL | AccessPrivileges.FILE_EXECUTE;
ace.Properties["AceFlags"].Value = 3;//AceFlags.ObjectInheritAce | AceFlags.ContainerInheritAce ;
ace.Properties["AceType"].Value = 0;//AceType.AccessAllowed;
ace.Properties["Trustee"].Value = trustee;
//修改ACL设置
ManagementObject secDescriptor = new ManagementClass("Win32_SecurityDescriptor");
secDescriptor["ControlFlags"] = 4;
secDescriptor["DACL"] = new ManagementObject[] { ace };
//设置添加共享
ManagementClass mc = new ManagementClass("win32_share");
ManagementBaseObject inParams = mc.GetMethodParameters("Create");
inParams["Path"] = "f:\\dannyr";
inParams["Name"] = "share of dannyr";
inParams["Type"] = 0x0;
inParams["MaximumAllowed"] = null; //=null 则用户数连接无限制
inParams["Description"] = null;
inParams["Password"] = null;
inParams["Access"] = secDescriptor; //=null 则使Everyone拥有完全控制权限
ManagementBaseObject outParams = mc.InvokeMethod("Create", inParams, null);
uint returnValue = (uint)outParams.Properties["ReturnValue"].Value;
string ErrorMessage = null;
switch (returnValue)
{
case 0: //Success
break;
case 2: //Access denied
ErrorMessage = "无权访问";
break;
case 8: //Unknown failure
ErrorMessage = "未知错误";
break;
case 9: //Invalid name
ErrorMessage = "非法的共享名";
break;
case 10: //Invalid level
ErrorMessage = "非法的层次";
break;
case 21: //Invalid parameter
ErrorMessage = "非法的参数";
break;
case 22: //Duplicate share
ErrorMessage = "重复共享";
break;
case 23: //Redirected path
ErrorMessage = "重定向路径";
break;
case 24: //Unknown device or directory
ErrorMessage = "未知的目录";
break;
case 25: //Net name not found
ErrorMessage = "网络名不存在";
break;
default:
break;
}
Access数据库对于文本和备注类型的数据类型定义（DATA_TYPE）都是为130，无法直接区分，找了N多网页，包括MSDN都没有描述有关COLUMN_FLAGS的说明，还是自己分析一下：
COLUMN_FLAGS为64位(8字节)的十六进制的值，组合了数据类型和必填字段等信息
其中最后2个字节有效，最后一个字节一直为0x0A,有变化的是最后第二个字节，即：
对于文本类型的为0x00;备注类型为0x80;
对于非必填字段为0x40;必填字段为0x60
组合后：
文本必填： 0x6A
文本非必填：0x4A
备注必填： 0xEA
备注非必填：0xCA
最后可以得到COLUMN_FLAGS右移7位后可以区分文本类型和备注类型
DataTable dt = m_OLEDBCon.GetOleDbSchemaTable(
OleDbSchemaGuid.Columns,
new object[] {null, null, "表名称", null});
DataRow[] drs = dt.Select("COLUMN_NAME='字段名称'");
if(drs.Length > 0 && Convert.ToInt32(drs[0]["DATA_TYPE"]) == 130) {
//文本类型
if ( (Convert.ToInt64(drs[0]["COLUMN_FLAGS"]) >> 7) == 1){
//=1为备注字段
}else{
//=0为文本字段
}
}
As is known,in many advanced programming languages(esp. object oriented ones) like c/c++,c#,Java,etc., the function is only one of the programming syntax constructs,unlike that in some pure interpreted programming lanuage such as Javascript,SmallTalk and so on,which are also object oriented,the function itself is a first-class object,however,for example:
function Foo() { // note: Foo is an object
this.sampleMemVar = 123;
this.sampleMemFun = function() {
}; // create a new function object
function() {}; // anonymouse function object
var f = function(){}; // equal to function f() {} declaration,also create new function object
}; As a result,foo can behaves in the same way as regular object do,that is to say,foo can have properties,member functions,and can be extended,see below:
Foo.prototype.sampleVar = 0;
Foo.prototype.sampleFun = function(arglist) {}; // prototype is one of the properties of object Foo
Foo.sampleStaticVar = "sample static variable"; // static variable
Foo.sampleStaticFun = function() // extend Foo with a static function
var foo = new Foo(); // applying new operator on a function object causing an instance of an Object is created with the members declared in the constructor,i.e.,Foo.
foo.toString(); // inherited from Object
typeof(foo); // you can call typeof operator on foo,where Object is returned
typeof(Foo); // call tpyeof operator on Foo,where Function is returned
printf(Foo.sampleStaticVar);
foo.sampleMemVar = 100; // access instance variable
Foo.sampleStaticFun(); // call static method
foo.sampleMemFun(); // call instance methodNo need to enumerate the examples any more. You can see that the function has no much differences from general objects,except that it does inherites from Function on the other hand.
Then how about the situation in c/c++,or others?
For example, we have a function,which can perform some action on two operands,and the specified action can only be determined at runtime.Then how to solve this problem?
Of course,you can use (memebr) function pointer like:
typedef int (*OpFunc)(int left,int right);
but you should first know the argument types and return type.
how about template?
template<class _Arg1,class _Arg2,class _Result>
_Result(*OpFunc)(_Arg1 arg1,_Arg2 arg2); // this does not compile
You could never use template directly on typedef or object declarations.
Then maybe you want to encapsulate the concept in this way:
template<class _Arg1,class _Arg2,class _Result>
class Performer
{
public:
typedef _Result (*OpFunc)(_Arg1,_Arg2);
Performer(OpFunc _opfunc) : m_opfunc(_opfunc)
{
_ASSERT(NULL != _opfunc);
}
_Result Perform(_Arg1 arg1,_Arg2 arg2)
{
return m_opfunc(arg1,arg2);
}
private:
OpFunc m_opfunc;
};
Yes,this works. However,function pointer itself is not an object oriented construct,as a result,lack of flexibility and extensibility.
Then,if you're familar with c#,you may want to use delegate.
And unlike template in c++,you can apply generic on delegate directly.
delegate _Result OpFunc<_Arg1,_Arg2,_Result>(_Arg1 arg1,_Arg2 arg2);
class Performer<_Arg1, _Arg2, _Result>
{
private OpFunc<_Arg1, _Arg2, _Result> opfun = null;
public Performer(OpFunc<_Arg1, _Arg2, _Result> _opfun)
{
if (null == _opfun) throw new ArgumentException();
this.opfun = _opfun;
}
public _Result Perform(_Arg1 arg1, _Arg2 arg2)
{
return opfun(arg1, arg2);
}
}
you can even implement you delegate in c++,only by making a wrapper to any function pointer.
No matter what you do with delegate,you are actually using function pointers,then again,lack of flexibility and extensibility.
So, why not use polymorphism?
If we can store the runtime action performer in an object,e.g.,action_performer,and we call the method on this object,where different object has different implementation for that action.
template<class _Arg1,class _Arg2,class _Result>
class PerformerBase
{
public:
virtual _Result Perform(_Arg1 arg1,_Arg2 arg2) = 0;
};
template<class _Arg1,class _Arg2,class _Result>
class AddPerformer : public PerformerBase<_Arg1,_Arg2,_Result>
{
public:
_Result Perform(_Arg1 arg1,_Arg2 arg2)
{
return arg1 + arg2;
}
};
template<class _Arg1,class _Arg2,class _Result>
class MinusPerformer : public PerformerBase<_Arg1,_Arg2,_Result>
{
public:
_Result Perform(_Arg1 arg1,_Arg2 arg2)
{
return arg1 - arg2;
}
};
Yes,this also works and we can gain much flexibility and extensibility from this solution.
Then if we we can use function object as we do in Javascript,we can gain much more.
Forget operator overloading?( return to your c++ textbook for a look:-))
we can obtain a function object by encapsulate the function and overload it call operator,i.e.().
For example,
class Functor
{
public:
int operator()(int a,int b) { return a + b; }
};
Functor myFuncObj;
int x = myFuncObj(1,2);
Quite easy,right?
OK,then let's return to our problem,which is now trivial,given below:
template<class _Arg1,class _Arg2,class _Result>
class FunctorBase
{
public:
virtual _Result operator()(_Arg1 arg1,_Arg2 arg2) = 0;
};
template<class _Arg1,class _Arg2,class _Result>
class AddFunctor : public FunctorBase<_Arg1,_Arg2,_Result>
{
public:
_Result operator()(_Arg1 arg1,_Arg2 arg2)
{
return arg1 + arg2;
}
};
template<class _Arg1,class _Arg2,class _Result>
class MinusFunctor : public FunctorBase<_Arg1,_Arg2,_Result>
{
public:
_Result operator()(_Arg1 arg1,_Arg2 arg2)
{
return arg1 - arg2;
}
};
template<class _Arg1,class _Arg2,class _Result>
class Performer
{
public:
Performer(FunctorBase<_Arg1,_Arg2,_Result> & functor)
: m_functor(functor)
{
}
_Result Perform(_Arg1 arg1,_Arg2 arg2)
{
return m_functor(arg1,arg2);
}
private:
FunctorBase<_Arg1,_Arg2,_Result> & m_functor;
};
In conclusion, you can implement your own specific function object(functor) even in c++,c#,etc.,then you can use function as general objects in your program with high flexibility,resuability and extensibility. Actually, if you look into the STL,you will find that many functions receive a functor as a parameter,e.g.,find_if in <algorithm> receives a predictor as a searching criteria. see declaration below:
template<class InputIterator, class Predicate>
InputIterator find_if(
InputIterator _First,
InputIterator _Last,
Predicate _Pred
);
then you can call like this:
int arr[] = {1,2,3,4,5};
int * found = find_if(arr,arr + _countof(arr),greater<int>(2)); // find element that is greater thatn 2.
functors are declared in <functional> in STL.