public ParsedName Parse(string rawName)
{
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var firstName = match.Groups["first"].Value;
if (!FirstNames.Contains(firstName.ToLowerInvariant()))
{
return(null);
}
var pn = new ParsedName(this.GetType().Name)
{
Title = match.Groups["title"].Value,
FirstName = match.Groups["first"].Value,
LastName = $"{match.Groups["last1"].Value} {match.Groups["last2"].Value}",
DisplayName = $"{match.Groups["first"].Value} {match.Groups["last1"].Value} {match.Groups["last2"].Value}",
Score = 100
};
return(pn);
}
public ParsedName Parse(string rawName)
{
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var pn = new ParsedName(this.GetType().Name)
{
DisplayName = rawName,
Score = 100
};
var matchedName = match.Groups["first"].Value;
if (NameComponentSets.LastNamesInUppercase.Contains(matchedName.ToUpper()))
{
pn.LastName = matchedName;
}
else
{
pn.FirstName = matchedName;
}
return(pn);
}
internal static Type GetType(
string typeName,
Func <AssemblyName, Assembly> assemblyResolver,
Func <Assembly, string, bool, Type> typeResolver,
bool throwOnError,
bool ignoreCase,
ref StackCrawlMark stackMark)
{
if (typeName == null)
{
throw new ArgumentNullException(nameof(typeName));
}
ParsedName pname = ParseName(typeName, false, 0, out int end_pos);
if (pname == null)
{
if (throwOnError)
{
throw new ArgumentException();
}
return(null);
}
return(ConstructType(pname, assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark));
}
/// <summary>
/// Returns a string representation of the node without any SWUM markup.
/// </summary>
/// <returns></returns>
public override string ToPlainString()
{
if (ParsedName != null)
{
return(ParsedName.ToPlainString());
}
else
{
return(Name);
}
}
public ParsedName Parse(string rawName)
{
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var pn = new ParsedName {
DisplayName = rawName,
Score = ParsedName.MaxScore
};
return(pn);
}
public ParsedName Parse(string rawName)
{
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var pn = new ParsedName {
FirstName = match.Groups["first"].Value,
LastName = match.Groups["last"].Value,
DisplayName = $"{match.Groups["first"].Value} {match.Groups["last"].Value}",
Score = 100
};
return(pn);
}
} // END_BuildMessage
static void Main(string[] args)
{
List <string> nameList = new List <string>()
{
"kevin bowe",
"bowe, kevin",
"Johnney Cash",
"Miles Davis",
"Plant, Robert",
"Lady Gaga",
"Lin-Manual Miranda"
};
foreach (string name in nameList)
{
// choose nameParser
INameParser nameParser;
switch (GetNameForm(name))
{
case "FirstLast": nameParser = new FirstLastParser();
break;
case "LastFirst": nameParser = new LastFirstParser();
break;
default: nameParser = new FirstLastParser();
break;
}
ParsedName parsedName = nameParser.ParseName(name);
// choose EmailSender
IEmailSender emailSender;
if (parsedName.Last.Length == 4)
{
emailSender = new MyEmailSender();
}
else
{
emailSender = new YourEmailSender();
}
string message = BuildMessage(name, parsedName, nameParser, emailSender);
emailSender.SendEmail("*****@*****.**", "*****@*****.**", "SUBJECT: Hello", message);
} // END_FOREACH
} // END_Main
public ParsedName Parse(string rawName)
{
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var pn = new ParsedName(this.GetType().Name)
{
FirstName = match.Groups["first"].Value,
MiddleName = match.Groups["middle"].Value,
LastName = $"{match.Groups["lastPart1"].Value}-{match.Groups["lastPart2"].Value}",
DisplayName = $"{match.Groups["first"].Value} {match.Groups["lastPart1"].Value}-{match.Groups["lastPart2"].Value}",
Score = 100
};
return(pn);
}
public ParsedName Parse(string rawName)
{
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var jobTitle = match.Groups["jobTitle"].Value;
var pn = new ParsedName {
Title = match.Groups["title"].Value,
FirstName = match.Groups["first"].Value,
DisplayName = $"{match.Groups["first"].Value} {jobTitle}",
Score = 200
};
return(pn);
}
public ParsedName Parse(string rawName)
{
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var pn = new ParsedName(this.GetType().Name)
{
FirstName = match.Groups["first"].Value,
LastName = match.Groups["last"].Value,
DisplayName = $"{match.Groups["first"].Value} {match.Groups["last"].Value}",
Suffix = match.Groups["suffix"].Value,
Score = 200
};
return(pn);
}
public ParsedName Parse(string rawName)
{
//Title should be Mr or Mr. or Ms or Ms. or Mrs or Mrs.
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var pn = new ParsedName {
Title = match.Groups["title"].Value,
FirstName = match.Groups["first"].Value,
LastName = match.Groups["last"].Value,
DisplayName = $"{match.Groups["first"].Value} {match.Groups["last"].Value}",
Score = 100
};
return(pn);
}
public ParsedName Parse(string rawName)
{
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var prefix = match.Groups["prefix"].Value;
var pn = new ParsedName {
Title = match.Groups["title"].Value,
FirstName = match.Groups["first"].Value,
LastName = prefix + " " + match.Groups["last"].Value,
DisplayName = $"{match.Groups["first"].Value} {prefix} {match.Groups["last"].Value}",
Score = 275
};
return(pn);
}
public ParsedName Parse(string rawName)
{
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var pn = new ParsedName(this.GetType().Name)
{
Title = match.Groups["title"].Value,
FirstName = match.Groups["first"].Value,
LastName = match.Groups["last"].Value,
NickName = match.Groups["nick"].Value,
DisplayName = $"{match.Groups["first"].Value} {match.Groups["last"].Value}",
Score = 100
};
return(pn);
}
public ParsedName Parse(string rawName)
{
var match = Rx.Match(rawName);
if (!match.Success)
{
return(null);
}
var prefix = match.Groups["prefix"].Value;
var pn = new ParsedName(this.GetType().Name)
{
FirstName = match.Groups["first"].Value,
MiddleName = match.Groups["middle"].Value,
LastName = prefix + " " + match.Groups["last"].Value,
DisplayName = $"{match.Groups["first"].Value} {prefix} {match.Groups["last"].Value}",
Score = 250
};
return(pn);
}
/// <summary>
/// Construct the email message body
/// </summary>
/// <param name="name">Pre-parsed name</param>
/// <param name="parsedName">Parsed name struct: First: Last:</param>
/// <param name="nameParser">NameParser object</param>
/// <param name="emailSender">EmailSender object</param>
/// <returns>String</returns>
private static string BuildMessage(string name, ParsedName parsedName, INameParser nameParser, IEmailSender emailSender)
{
string parserName = nameParser.GetType().ToString().Split('+')[1];
string emailSenderName = emailSender.GetType().ToString().Split('+')[1];;
string message = string.Format(
"Message Body\n" +
"------------\n" +
"Original Input Name: {0} \n" +
"First: {1} \n" +
"Last: {2} \n" +
"Name Parsed With: {3} \n" +
"Message Sent With: {4} \n\n\n",
name,
parsedName.First,
parsedName.Last,
parserName,
emailSenderName
);
return(message);
} // END_BuildMessage
private static Type?ConstructType(
ParsedName pname,
Func <AssemblyName, Assembly?>?assemblyResolver,
Func <Assembly, string, bool, Type?>?typeResolver,
bool throwOnError,
bool ignoreCase,
ref StackCrawlMark stackMark)
{
// Resolve assembly
Assembly?assembly = null;
if (pname.AssemblyName != null)
{
assembly = ResolveAssembly(pname.AssemblyName, assemblyResolver, throwOnError, ref stackMark);
if (assembly == null)
{
// If throwOnError is true, an exception was already thrown
return(null);
}
}
// Resolve base type
Type?type = ResolveType(assembly !, pname.Names !, typeResolver, throwOnError, ignoreCase, ref stackMark);
if (type == null)
{
return(null);
}
// Resolve type arguments
if (pname.TypeArguments != null)
{
var args = new Type?[pname.TypeArguments.Count];
for (int i = 0; i < pname.TypeArguments.Count; ++i)
{
args[i] = ConstructType(pname.TypeArguments[i], assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
if (args[i] == null)
{
return(null);
}
}
type = type.MakeGenericType(args !);
}
// Resolve modifiers
if (pname.Modifiers != null)
{
bool bounded = false;
foreach (int mod in pname.Modifiers)
{
switch (mod)
{
case 0:
type = type.MakeByRefType();
break;
case -1:
type = type.MakePointerType();
break;
case -2:
bounded = true;
break;
case 1:
if (bounded)
{
type = type.MakeArrayType(1);
}
else
{
type = type.MakeArrayType();
}
break;
default:
type = type.MakeArrayType(mod);
break;
}
}
}
return(type);
}
// Ported from the C version in mono_reflection_parse_type_checked ()
// Entries to the Names list are unescaped to internal form while AssemblyName is not, in an effort to maintain
// consistency with our native parser. Since this function is just called recursively, that should also be true
// for ParsedNames in TypeArguments.
private static ParsedName?ParseName(string name, bool recursed, int pos, out int end_pos)
{
end_pos = 0;
while (pos < name.Length && name[pos] == ' ')
{
pos++;
}
var res = new ParsedName()
{
Names = new List <string>()
};
int start = pos;
int name_start = pos;
bool in_modifiers = false;
while (pos < name.Length)
{
switch (name[pos])
{
case '+':
res.Names.Add(UnescapeTypeName(name.Substring(name_start, pos - name_start)));
name_start = pos + 1;
break;
case '\\':
pos++;
break;
case '&':
case '*':
case '[':
case ',':
case ']':
in_modifiers = true;
break;
default:
break;
}
if (in_modifiers)
{
break;
}
pos++;
}
res.Names.Add(UnescapeTypeName(name.Substring(name_start, pos - name_start)));
bool isbyref = false;
bool isptr = false;
int rank = -1;
bool end = false;
while (pos < name.Length && !end)
{
switch (name[pos])
{
case '&':
if (isbyref)
{
return(null);
}
pos++;
isbyref = true;
isptr = false;
if (res.Modifiers == null)
{
res.Modifiers = new List <int>();
}
res.Modifiers.Add(0);
break;
case '*':
if (isbyref)
{
return(null);
}
pos++;
if (res.Modifiers == null)
{
res.Modifiers = new List <int>();
}
res.Modifiers.Add(-1);
isptr = true;
break;
case '[':
// An array or generic arguments
if (isbyref)
{
return(null);
}
pos++;
if (pos == name.Length)
{
return(null);
}
if (name[pos] == ',' || name[pos] == '*' || name[pos] == ']')
{
// Array
bool bounded = false;
isptr = false;
rank = 1;
while (pos < name.Length)
{
if (name[pos] == ']')
{
break;
}
if (name[pos] == ',')
{
rank++;
}
else if (name[pos] == '*') /* '*' means unknown lower bound */
{
bounded = true;
}
else
{
return(null);
}
pos++;
}
if (pos == name.Length)
{
return(null);
}
if (name[pos] != ']')
{
return(null);
}
pos++;
/* bounded only allowed when rank == 1 */
if (bounded && rank > 1)
{
return(null);
}
/* n.b. bounded needs both modifiers: -2 == bounded, 1 == rank 1 array */
if (res.Modifiers == null)
{
res.Modifiers = new List <int>();
}
if (bounded)
{
res.Modifiers.Add(-2);
}
res.Modifiers.Add(rank);
}
else
{
// Generic args
if (rank > 0 || isptr)
{
return(null);
}
isptr = false;
res.TypeArguments = new List <ParsedName>();
while (pos < name.Length)
{
while (pos < name.Length && name[pos] == ' ')
{
pos++;
}
bool fqname = false;
if (pos < name.Length && name[pos] == '[')
{
pos++;
fqname = true;
}
ParsedName?arg = ParseName(name, true, pos, out pos);
if (arg == null)
{
return(null);
}
res.TypeArguments.Add(arg);
/*MS is lenient on [] delimited parameters that aren't fqn - and F# uses them.*/
if (fqname && pos < name.Length && name[pos] != ']')
{
if (name[pos] != ',')
{
return(null);
}
pos++;
int aname_start = pos;
while (pos < name.Length && name[pos] != ']')
{
pos++;
}
if (pos == name.Length)
{
return(null);
}
while (char.IsWhiteSpace(name[aname_start]))
{
aname_start++;
}
if (aname_start == pos)
{
return(null);
}
arg.AssemblyName = name.Substring(aname_start, pos - aname_start);
pos++;
}
else if (fqname && pos < name.Length && name[pos] == ']')
{
pos++;
}
if (pos < name.Length && name[pos] == ']')
{
pos++;
break;
}
else if (pos == name.Length)
{
return(null);
}
pos++;
}
}
break;
case ']':
if (recursed)
{
end = true;
break;
}
return(null);
case ',':
if (recursed)
{
end = true;
break;
}
pos++;
while (pos < name.Length && char.IsWhiteSpace(name[pos]))
{
pos++;
}
if (pos == name.Length)
{
return(null);
}
res.AssemblyName = name.Substring(pos);
end = true;
break;
default:
return(null);
}
if (end)
{
break;
}
}
end_pos = pos;
return(res);
}
private static ParsedTypeName ParseCSharp(string name, int startIndex, out int endIndex)
{
char[] splitAt = new char[] { '.', '<', '[', '*', ',', '>' };
List <IParsedToken> parts = new List <IParsedToken>();
ParsedTypeName baseType = null;
endIndex = startIndex;
while (startIndex < name.Length && (endIndex = name.IndexOfAny(splitAt, startIndex)) >= 0)
{
switch (name[endIndex])
{
case '.':
ParsedName n;
if (!ParsedName.TryCreate(name.Substring(startIndex, endIndex - startIndex), out n))
{
throw new FormatException("Invalid name at index " + startIndex.ToString());
}
parts.Add(n);
break;
case '>':
case ',':
return(new ParsedTypeName(baseType, parts));
case '<':
List <ParsedTypeName> genericArgs = new List <ParsedTypeName>();
do
{
endIndex++;
while (endIndex < name.Length && Char.IsWhiteSpace(name[endIndex]))
{
endIndex++;
}
if (endIndex == name.Length)
{
throw new FormatException("Unexpected end of string");
}
genericArgs.Add(ParseCSharp(name, endIndex, out endIndex));
if (endIndex == name.Length)
{
throw new FormatException("Unexpected end of string");
}
} while (name[endIndex] == ',');
if (name[endIndex] != '>')
{
throw new FormatException("Invalid character at index " + endIndex.ToString());
}
break;
case '*':
if (parts.Count == 0)
{
throw new FormatException("Invalid character at index " + endIndex.ToString());
}
baseType = new ParsedTypeName(baseType, parts);
parts = new List <IParsedToken>();
parts.Add(new ParsedPointer());
break;
case '[':
int rank = 0;
do
{
rank++;
endIndex++;
while (endIndex < name.Length && Char.IsWhiteSpace(name[endIndex]))
{
endIndex++;
}
if (endIndex == name.Length)
{
throw new FormatException("Unexpected end of string");
}
} while (name[endIndex] == ',');
if (name[endIndex] != ']')
{
throw new FormatException("Invalid character at index " + endIndex.ToString());
}
baseType = new ParsedTypeName(baseType, parts);
parts = new List <IParsedToken>();
parts.Add(new ParsedIndexer(rank));
break;
}
startIndex = endIndex + 1;
}
endIndex = name.Length;
return(new ParsedTypeName(baseType, parts));
}
/// <summary>
/// Returns a string representation of the node. This is simply the string representation of the ParsedName.
/// </summary>
/// <returns>A string representation of the node.</returns>
public override string ToString()
{
return(ParsedName.ToString());
}
