What? Yet another argument parsing class?! What for? Well, actually for a couple of reasons:
ArgumentFormatException is raised.
ResourceManager, a CultureInfo and a resource ID and the argument name/alias will be automatically updated according to resource file). This works for switches, named values and flags.I want to thank Ray Hayes for his idea of automatically setting field/property by judiciously using custom attributes. This is a great example of that proverbial 1% of inspiration. :) Take a look at his article here.
This is an example quickly showing how you might use the class, more or less taken from the included demo, which by the way is a utility I posted some time ago on this site. You can read the article here.
using Common;
using Common.IO;
using System;
using System.Collections;
using System.Collections.Specialized;
using System.IO;
namespace xmove
{
class XMove
{
private static System.Resources.ResourceManager m_resMan;
// this argument can either be named "batch", "file", "batchFile"
// or even "smurf" if you fancy it
[AutoSetMember("batch", "file", "batchFile", "smurf")]
private static String m_batchFile;
[AutoSetMember("yc", SwitchMeansFalse=true)]
private static bool m_confirmMove = true;
[AutoSetMember("yc", SwitchMeansFalse=true)]
private static bool m_confirmOverwrite = true;
[AutoSetMember("r")]
private static bool m_recursive = false;
private static FindFile.SearchAttributes m_searchAttributes;
[STAThread]
static void Main(string[] args)
{
// a FlagCollection contains all accepted flags
FlagCollection flags = new FlagCollection();
// here we add the flag named "a" with accepted values
// a,c,d,h,...
// the argument must then looks like "-a<VALUES>" on the command
// line
flags.Add("a", "acdehnorstFA");
// create a new parser that accept all argument formats,
// is case sensitive and accept provided flags
ArgumentParser parser = new ArgumentParser(ArgumentFormats.All,
false, flags);
// parse the arguments with the result stored in a
// StringDictionary
StringDictionary theArgs = parser.Parse(args);
// automatically set all static members of the class XMove
parser.AutoSetMembers(typeof(XMove));
// now, the values of m_batchFile, m_confirmMove,
// m_confirmOverwrite and m_recursive are all set !
// the corresponding arguments have been moved to
// parser.HandledArguments
// the remaining arguments are in parser.UnhandledArguments
// one argument remains which can't be set automatically
if (theArgs.ContainsKey("a"))
{
String attribs = theArgs[m_resMan.GetString("app0019")];
if (attribs.IndexOf("A") > -1)
m_searchAttributes |= FindFile.SearchAttributes.All;
if (attribs.IndexOf("F") > -1)
m_searchAttributes |= FindFile.SearchAttributes.AnyFile;
.........
}
// here we load the resources for the application
LoadResources();
// we then set the resource manager of the
// AutoSetMemberAttribute accordingly
// why this property is static is explained in the
// "How it Works" section of this article
AutoSetMemberAttribute.Resources = m_resMan;
// create a new instance of Dummy class
Dummy dummy = new Dummy();
// then set members of this class, no matter if they are
// static, instance, public, private, protected, internal
// type conversion is done automatically !
parser.AutoSetMembers(dummy);
}
private void LoadResources()
{
....
}
}
class Dummy
{
public enum MyEnum
{
a,
b,
c,
d
}
[AutoSetMember("foo")]
private static int field1;
// here we indicate that the argument name is to be retrieved using
// the ResourceManager at runtime
[AutoSetMember(ResID="0001")]
private Double field2;
// same here
[AutoSetMember(ResID="0002")]
protected String Property1
{
get {...}
set {...}
}
[AutoSetMember("buzz")]
public MyEnum Property2
{
get {...}
set {...}
}
}
}
Two main classes do all the work: ArgumentParser and AutoSetMemberAttribute. As usual, contructors let you directly set one or more properties, so I will skip them.
public char[] AllowedPrefixes [get, set]
The accepted prefix(es).
public ArgumentFormats ArgumentFormats [get, set]The accepted argument format(s).
public char[] AssignSymbols [get, set]
The accepted assignation symbol(s).
public string CustomPattern [get, set]
An additional or overriding pattern. In the pattern, use capture name constants made public by this class (ArgumentNameCaptureName, ArgumentValueCaptureName, FlagNameCaptureName, FlagsCaptureName and PrefixCaptureName).
public StringDictionary HandledArguments [get]
The argument(s) that have been automatically set by AutoSetMembers method.
public StringDictionary UnhandledArguments [get]
The argument(s) that have not been automatically set by AutoSetMembers method.
public bool UseOnlyCustomPattern [get, set]
Indicates if the custom pattern provided is overriding the internal pattern automatically generated.
public StringDictionary Parse(string[] args)
Parses the array of arguments and returns the dictionary of parsed argumentsUnhandledArgument property is also updated accordingly.
public void AutoSetMembers(Assembly assembly)public void AutoSetMembers(Type type)public void AutoSetMembers(object instance)public void AutoSetMembers(object classToProcess, MemberInfo member)
Automatically sets member(s) of the provided assembly, type, class instance. Also works for a single field/property.
public void Clear()
Clears all saved arguments (both handled and unhandled).
private void BuildPattern()
Builds the pattern to be used when parsing each argument.
private void SetMemberValue(object instance, MemberInfo memberInfo, object value)Set the static or instance member to the specified value.
public static CultureInfo Culture [get, set]
The culture to be used for retrieving culture aware aliases.
public static ResourceManager Resources [get, set]
The resource manager to be used for retrieving culture aware aliases.
public ArrayList Aliases [get]
Command line argument's name or aliases if many names are possible.
public string Description [get, set]
The description of the command line argument.
public object ID [get, set]
An ID (can be anything you want).
public string ResID [get, set]
The resource ID to be used when retrieving culture aware aliases.
public bool SwitchMeansFalse [get, set]
Indicates if the meaning of a switch is false instead of true as usual.
Here is a quick explanation of the regex that is constructed by ArgumentParser.BuildPattern() private method. Variables are indicated by capitalized names and are to be replaced at runtime.
// The whole parsing string (with all possible argument formats) :
// ---------------------------------------------------------------
// (CUSTOM_PATTERN)
// |(^(?[PREFIXES])(?<FLAGNAME>)FLAG_NAMES)(?<FLAGS>[FlagsCaptureName]+)$)
// |(^(?[PREFIXES])(?<NAME>[^EQUAL_SYMBOLS]+)([EQUAL_SYMBOLS](?<VALUE>.+))?$)
// |(LITERAL_STRING_SYMBOL?(?<VALUE>.*))
//
// Again, but commented :
// ----------------------
// (CUSTOM_PATTERN)| # custom pattern, if any (it has priority over
// # standard pattern)
//
// foreach flag in FlagCollection :
//
// (^
// (?[PREFIXES]) # mandatory prefix
// (?<FLAGNAME>)FLAG_NAMES) # flag name
// (?<FLAGS>[FlagsCaptureName]+) # flag value
// $)|
//
// (^
// (?[PREFIXES]) # mandatory prefix
// (?<NAME>[^EQUAL_SYMBOLS]+) # argument name (which includes flag
// # name/values)
// ([EQUAL_SYMBOLS](?<VALUE>.+))? # argument value, if any
// $)
//
// |(
// LITERAL_STRING_SYMBOL? # optional @ caracter indicating literal string
// (?<VALUE>.*) # standalone value (will be given an index when
// # parsed in Parse() method)
// )
At design time, AutoSetMemberAttribute custom attribute is used to specify which argument will be used to set the affected member. Other informations include description, resource ID and an ID that you might use at your convenience.
At runtime, you can set the AutoSetMemberAtttribute static properties Resource and Culture. It's necessary to make those properties static because attributes are serialized at compile time, so they can only have constant values as instance properties.
When you execute ArgumentParser.SetAutoMembers(...), the following occurs :
AutoSetMember attributes will be located using reflection.
ArgumentParser.SetMemberValue(...).
ArgumentParser.UnhandledArguments and added to ArgumentParser.HandledArguments./// <SUMMARY>
/// Automatically sets members for the provided
/// <SEE cref="System.Reflection.Assembly" />.
/// </SUMMARY>
/// The <SEE cref="System.Reflection.Assembly" /> to process.
public void AutoSetMembers(Assembly assembly)
{
Type[] types = assembly.GetTypes();
foreach (Type type in types)
AutoSetMembers(type);
}
/// <SUMMARY>
/// Automatically sets members for the provided <SEE cref="System.Type" />.
/// </SUMMARY>
/// The <SEE cref="System.Type" /> to process.
/// <REMARKS>Only static members will be processed.</REMARKS>
public void AutoSetMembers(Type type)
{
MemberInfo[] members = type.FindMembers(
AutoSetMemberAttribute.SupportedMemberTypes,
AutoSetMemberAttribute.SupportedBindingFlags, Type.FilterName, "*");
foreach (MemberInfo member in members)
AutoSetMembers(type, member);
}
/// <SUMMARY>
/// Automatically sets members for the provided class instance.
/// </SUMMARY>
/// The class instance to process. Must not be null.
/// <REMARKS>Both static and instance members will be processed.</REMARKS>
public void AutoSetMembers(object instance)
{
MemberInfo[] members = instance.GetType().FindMembers(
AutoSetMemberAttribute.SupportedMemberTypes,
AutoSetMemberAttribute.SupportedBindingFlags, Type.FilterName, "*");
foreach (MemberInfo member in members)
AutoSetMembers(instance, member);
}
/// <SUMMARY>
/// Automatically sets member of the provided class instance or
/// <SEE cref="System.Type" />.
/// </SUMMARY>
/// The class instance or <SEE cref="System.Type" /> to process.
/// The member which will be set. Must be a field or a property.
/// <REMARKS>Both static and instance members are accepted.</REMARKS>
public void AutoSetMembers(object classToProcess, MemberInfo member)
{
AutoSetMemberAttribute attrib = Attribute.GetCustomAttribute(member,
typeof(AutoSetMemberAttribute)) as AutoSetMemberAttribute;
if (attrib != null)
{
if (attrib.ResID != null && AutoSetMemberAttribute.Resources != null)
attrib.Aliases.Add(AutoSetMemberAttribute.Resources.GetString(
attrib.ResID, AutoSetMemberAttribute.Culture));
String argValue = null;
bool found = false;
foreach (String alias in attrib.Aliases)
{
if (m_unhandled.ContainsKey(alias))
{
argValue = (String)m_unhandled[alias];
m_handled.Add(alias, argValue);
m_unhandled.Remove(alias);
found = true;
break;
}
else if (m_handled.ContainsKey(alias))
{
argValue = (String)m_handled[alias];
found = true;
break;
}
}
if (found)
{
Type memberType = null;
switch (member.MemberType)
{
case MemberTypes.Property:
memberType = ((PropertyInfo)member).PropertyType;
break;
case MemberTypes.Field:
memberType = ((FieldInfo)member).FieldType;
break;
}
if (memberType == typeof(bool))
{
if (argValue == "")
SetMemberValue(classToProcess, member,
!attrib.SwitchMeansFalse);
else if (argValue == Boolean.FalseString ||
argValue == Boolean.TrueString)
SetMemberValue(classToProcess, member,
Boolean.Parse(argValue));
else
// last chance ... if can't parse it as integer, an
// exception will be raised
SetMemberValue(classToProcess, member,
Int32.Parse(argValue) != 0);
}
else if (memberType == typeof(String))
SetMemberValue(classToProcess, member, argValue);
else if (memberType.IsEnum)
{
object value = Enum.Parse(memberType, argValue,
m_ignoreCase);
SetMemberValue(classToProcess, member, value);
}
else if (memberType.IsValueType)
SetMemberValue(classToProcess, member,
Convert.ChangeType(argValue, memberType));
}
}
}
/// <SUMMARY>
/// Sets the static or instance member (property or field) to the specified
/// value.
/// </SUMMARY>
/// The class instance or <SEE cref="System.Type" /> to be used.
/// The member to be set.
/// The new value of the member.
private void SetMemberValue(object instance, MemberInfo memberInfo,
object value)
{
if (memberInfo is PropertyInfo)
{
PropertyInfo pi = (PropertyInfo) memberInfo;
if (pi.CanWrite)
{
MethodInfo methodInfo = pi.GetSetMethod(true);
BindingFlags bindingFlags = BindingFlags.SetProperty;
if (methodInfo.IsStatic)
bindingFlags |= BindingFlags.Static;
pi.SetValue(instance, value, bindingFlags, null, null, null);
}
}
else if (memberInfo is FieldInfo)
{
FieldInfo fi = (FieldInfo) memberInfo;
BindingFlags bindingFlags = BindingFlags.SetField;
if (fi.IsStatic)
bindingFlags |= BindingFlags.Static;
fi.SetValue(instance, value, bindingFlags, null, null);
}
}
| You must Sign In to use this message board. | |||||
|
|||||
|
|||||
), so I will check if I should update it or not. But yes, seems like the version currently on CP has a bug 
I have currently no time to update the article, but you can do the following: