private string Get(NameGender gender, NameComponents components, string separator, char?forcedSingleLetter)
{
string firstName = components != NameComponents.LastNameOnly
? this.GetName(gender, forcedSingleLetter)
: "";
string lastName = components != NameComponents.FirstNameOnly
? Helpers.GetToken(this.lastNames, this.randomIndex, forcedSingleLetter)
: "";
string middleName = components == NameComponents.FirstNameMiddleNameLastName
? this.GetName(gender, forcedSingleLetter)
: "";
switch (components)
{
case NameComponents.FirstNameLastName:
return($"{firstName}{separator}{lastName}");
case NameComponents.FirstNameMiddleNameLastName:
return($"{firstName}{separator}{middleName}{separator}{lastName}");
case NameComponents.FirstNameOnly:
return(firstName);
case NameComponents.LastNameOnly:
return(lastName);
case NameComponents.LastNameFirstName:
return($"{lastName}{separator}{firstName}");
default:
throw new ArgumentOutOfRangeException(nameof(components), components, null);
}
}
/// <summary>
/// Gets a random name based on the specified settings
/// </summary>
/// <param name="gender">The gender.</param>
/// <param name="components">The components.</param>
/// <param name="separator">The separator.</param>
/// <param name="forceSingleLetter">if set to <c>true</c> [force single letter].</param>
/// <param name="lengthRestriction">Maximum number of characters in the returned string</param>
/// <returns>System.String.</returns>
/// <exception cref="ArgumentOutOfRangeException">components - null</exception>
public string Get(NameGender gender = NameGender.Any,
NameComponents components = NameComponents.FirstNameLastName, string separator = " ",
bool forceSingleLetter = false, int lengthRestriction = 0)
{
char?forcedSingleLetter = Helpers.GetForcedSingleCharacter(forceSingleLetter, this.randomIndex);
gender = this.DetermineGender(gender);
int attempt = 0;
while (true) //if there is a length restriction, retry a couple of times. If the string is still too long, just trim it
{
attempt++;
var name = this.Get(gender, components, separator, forcedSingleLetter);
if (lengthRestriction <= 0)
{
return(name);
}
else if (name.Length <= lengthRestriction)
{
return(name);
}
if (attempt >= 100)
{
return(name.Remove(lengthRestriction));
}
}
}
/// <summary>
/// Checks form and picks the correct GetNames overload-method
/// </summary>
/// <param name="FormData"></param>
/// <returns></returns>
public static List <NameModel> GetNames(NameValueCollection FormData)
{
NameType nameTypeValue = (NameType)Enum.Parse(typeof(NameType), FormData.Get("nameTypeData"));
NameGender nameGenderValue = (NameGender)Enum.Parse(typeof(NameGender), FormData.Get("nameGenderData"));
int nameLimitValue = int.Parse(FormData.Get("nameLimitData"));
List <NameModel> nameModelList;
if (nameTypeValue != NameType.Both && nameGenderValue != NameGender.Both)
{
nameModelList = NameAPI.NameService.GetNameList(nameTypeValue, nameGenderValue, nameLimitValue);
}
else if (nameTypeValue != NameType.Both)
{
nameModelList = NameAPI.NameService.GetNameList(nameTypeValue, nameLimitValue);
}
else if (nameGenderValue != NameGender.Both)
{
nameModelList = NameAPI.NameService.GetNameList(nameGenderValue, nameLimitValue);
}
else
{
nameModelList = NameAPI.NameService.GetNameList(nameLimitValue);
}
return(nameModelList);
}
/// <summary>
/// Prepares list of names based on the limit input and gender
/// </summary>
/// <param name="gender"></param>
/// <param name="limit"></param>
public static List <NameModel> GetNameList(NameGender gender, int limit)
{
queryValues.gender = gender.ToString().ToLower();
queryValues.limit = limit.ToString();
// Prepares a list of names from the response of the query
List <NameModel> nameList = PrepareNameList();
return(nameList);
}
public static IEnumerable<Name> GetRandomNames(int count, NameGender nameGender = NameGender.Both)
{
var enumerator = RandomNameEnumerator(nameGender);
while (count-- > 0)
{
enumerator.MoveNext();
yield return enumerator.Current;
}
}
/// <summary>
/// Gets an IEnumerable of random name based on the specified settings.
/// <para>Enumerating the same result set multiple times will yield different results</para>
/// </summary>
/// <param name="numberOfNamesToReturn"></param>
/// <param name="gender">The gender.</param>
/// <param name="components">The components.</param>
/// <param name="separator">The separator.</param>
/// <param name="forceSingleLetter">if set to <c>true</c> [force single letter].</param>
/// <param name="lengthRestriction">Maximum number of characters in the returned string</param>
/// <returns>System.String.</returns>
/// <exception cref="ArgumentOutOfRangeException">components - null</exception>
public IEnumerable <string> Get(int numberOfNamesToReturn, NameGender gender = NameGender.Any,
NameComponents components = NameComponents.FirstNameLastName, string separator = " ",
bool forceSingleLetter = false, int lengthRestriction = 0)
{
for (int i = 0; i < numberOfNamesToReturn; i++)
{
yield return(this.Get(gender, components, separator, forceSingleLetter, lengthRestriction));
}
}
public static IEnumerable <Name> GetRandomNames(int count, NameGender nameGender = NameGender.Both)
{
var enumerator = RandomNameEnumerator(nameGender);
while (count-- > 0)
{
enumerator.MoveNext();
yield return(enumerator.Current);
}
}
public ActionResult Reload(NameGender gender, NameType type, int limit)
{
// storing the choises in the predefined variables
ctrlGender = gender;
ctrlType = type;
ctrlLimit = limit;
// Getting the list from the NameAPI library
nameList = NameService.GetNameList(type, gender, limit);
return(View("Index", nameList));
}
// method to GetNameList with two parameters Limit & Gender
public static List <NameModel> GetNameList(NameGender gender, int limit)
{
// changing the passed strings to lowercase to match json data from NameAPI
string genderLowerCase = gender.ToString().ToLower();
// creating string to get JSON-data from NameAPI
string url = urlGender + gender + urlType + "both" + urlLimit + limit;
// Calling method GetJsonData and passing the required url as well
json_data = GetJsonData(url);
// convert string of Json-data to list of NameModel
jsonResult = GetNames(json_data);
return(jsonResult);
}
private string GetName(NameGender gender, char?forcedSingleLetter)
{
switch (gender)
{
case NameGender.Any:
return($"{Helpers.GetToken(this.allFirstNames, this.randomIndex, forcedSingleLetter)}");
case NameGender.Female:
return($"{Helpers.GetToken(this.femaleFirstNames, this.randomIndex, forcedSingleLetter)}");
case NameGender.Male:
return($"{Helpers.GetToken(this.maleFirstNames, this.randomIndex, forcedSingleLetter)}");
default:
throw new ArgumentOutOfRangeException(nameof(gender), gender, null);
}
}
public static IEnumerator <string> RandomFirstNameEnumerator(NameGender nameGender = NameGender.Both)
{
var maleMax = MaleFirstNames.Length;
var femaleMax = FemaleFirstNames.Length;
var rand = new System.Random();
while (true)
{
if (nameGender == NameGender.Male || nameGender == NameGender.Both)
{
yield return(MaleFirstNames[rand.Next(0, maleMax)]);
}
if (nameGender == NameGender.Female || nameGender == NameGender.Both)
{
yield return(FemaleFirstNames[rand.Next(0, femaleMax)]);
}
}
}
private NameGender DetermineGender(NameGender gender)
{
if (gender != NameGender.Any)
{
return(gender);
}
else
{
var diceRoll = this.randomIndex.Get(2);
if (diceRoll == 0)
{
return(NameGender.Female);
}
else
{
return(NameGender.Male);
}
}
}
// ReSharper disable FunctionNeverReturns
// These are enumerators that keep yielding values as long as you ask for them
// They never stop returning names; a caller pulls the number of names that it needs.
public static IEnumerator<Name> RandomNameEnumerator(NameGender nameGender = NameGender.Both)
{
// If NameGender.Both, alternate between male and female names
var isMaleA = nameGender == NameGender.Both || nameGender == NameGender.Male;
var isMaleB = nameGender == NameGender.Male;
var genderA = isMaleA ? "M" : "F";
var firstNameEnumeratorA =
RandomFirstNameEnumerator((isMaleA) ? NameGender.Male : NameGender.Female);
var genderB = isMaleB ? "M" : "F";
var firstNameEnumeratorB =
RandomFirstNameEnumerator((isMaleB) ? NameGender.Male : NameGender.Female);
var lastNameEnumerator = RandomLastNameEnumerator();
while (true)
{
firstNameEnumeratorA.MoveNext();
lastNameEnumerator.MoveNext();
yield return new Name
{
First = firstNameEnumeratorA.Current,
Last = lastNameEnumerator.Current,
Gender = genderA,
};
firstNameEnumeratorB.MoveNext();
lastNameEnumerator.MoveNext();
yield return new Name
{
First = firstNameEnumeratorB.Current,
Last = lastNameEnumerator.Current,
Gender = genderB,
};
}
}
// ReSharper disable FunctionNeverReturns
// These are enumerators that keep yielding values as long as you ask for them
// They never stop returning names; a caller pulls the number of names that it needs.
public static IEnumerator <Name> RandomNameEnumerator(NameGender nameGender = NameGender.Both)
{
// If NameGender.Both, alternate between male and female names
var isMaleA = nameGender == NameGender.Both || nameGender == NameGender.Male;
var isMaleB = nameGender == NameGender.Male;
var genderA = isMaleA ? "M" : "F";
var firstNameEnumeratorA =
RandomFirstNameEnumerator((isMaleA) ? NameGender.Male : NameGender.Female);
var genderB = isMaleB ? "M" : "F";
var firstNameEnumeratorB =
RandomFirstNameEnumerator((isMaleB) ? NameGender.Male : NameGender.Female);
var lastNameEnumerator = RandomLastNameEnumerator();
while (true)
{
firstNameEnumeratorA.MoveNext();
lastNameEnumerator.MoveNext();
yield return(new Name
{
First = firstNameEnumeratorA.Current,
Last = lastNameEnumerator.Current,
Gender = genderA,
});
firstNameEnumeratorB.MoveNext();
lastNameEnumerator.MoveNext();
yield return(new Name
{
First = firstNameEnumeratorB.Current,
Last = lastNameEnumerator.Current,
Gender = genderB,
});
}
}
public static IEnumerator<string> RandomFirstNameEnumerator(NameGender nameGender = NameGender.Both)
{
var maleMax = MaleFirstNames.Length;
var femaleMax = FemaleFirstNames.Length;
var rand = new System.Random();
while (true)
{
if (nameGender == NameGender.Male || nameGender == NameGender.Both)
yield return MaleFirstNames[rand.Next(0, maleMax)];
if (nameGender == NameGender.Female || nameGender == NameGender.Both)
yield return FemaleFirstNames[rand.Next(0, femaleMax)];
}
}
