public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
{
IAstronaut astronaut = astronauts.FirstOrDefault(a => a.CanBreath);
if (planet == null)
{
return;
}
if (astronauts == null)
{
return;
}
if (planet.Items.Count == 0)
{
return;
}
while (astronauts.Any(a => a.CanBreath) && planet.Items.Count > 0)
{
string item = planet.Items.FirstOrDefault();
if (!astronaut.CanBreath)
{
astronaut = astronauts.FirstOrDefault(a => a.CanBreath);
continue;
}
else
{
astronaut.Breath();
astronaut.Bag.Items.Add(item);
planet.Items.Remove(item);
}
}
}
public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
{
while (true)
{
IAstronaut astronaut = astronauts.FirstOrDefault(a => a.CanBreath);
if (astronaut == null)
{
break;
}
while (planet.Items.Count != 0)
{
string item = planet.Items.FirstOrDefault();
astronaut.Breath();
astronaut.Bag.AddItem(item);
planet.RemoveItem(item);
if (astronaut.CanBreath == false)
{
break;
}
}
if (planet.Items.Count == 0)
{
break;
}
}
}
public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
{
while (true)
{
IAstronaut astronautCurrent = astronauts.FirstOrDefault(a => a.CanBreath);
if (astronautCurrent == null)
{
break;
}
string item = planet.Items.FirstOrDefault();
if (item == null)
{
break;
}
astronautCurrent.Bag.Items.Add(item);
astronautCurrent.Breath();
planet.Items.Remove(item);
//if (!astronautCurrent.CanBreath)
//{
// break;
//}
}
}
public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
{
while (true)
{
IAstronaut astronaut = astronauts.FirstOrDefault(a => a.CanBreath == true);
if (astronaut == null)
{
break;
}
string item = planet.Items.FirstOrDefault();
if (item == null)
{
break;
}
astronaut.Breath();
if (astronaut.CanBreath == false)
{
continue;
}
astronaut.Bag.Items.Add(item);
planet.Items.Remove(item);
}
}
public string AddAstronaut(string type, string astronautName)
{
IAstronaut astronaut = null;
if (type == "Meteorologist")
{
astronaut = new Meteorologist(astronautName);
}
else if (type == "Geodesist")
{
astronaut = new Geodesist(astronautName);
}
else if (type == "Biologist")
{
astronaut = new Biologist(astronautName);
}
else
{
throw new InvalidOperationException(ExceptionMessages.InvalidAstronautType);
}
this.astronautRepository.Add(astronaut);
return(string.Format(OutputMessages.AstronautAdded,
type,
astronautName));
}
public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
{
while (true)
{
IAstronaut currentAstronaut = astronauts.FirstOrDefault(x => x.CanBreath);
if (currentAstronaut == null)
{
break;
}
while (planet.Items.Count > 0)
{
string item = planet.Items.FirstOrDefault();
currentAstronaut.Breath();
currentAstronaut.Bag.Items.Add(item);
planet.Items.Remove(item);
if (!currentAstronaut.CanBreath)
{
break;
}
}
if (planet.Items.Count == 0)
{
break;
}
}
}
public string AddAstronaut(string type, string astronautName)
{
IAstronaut astronaut = null;
switch (type)
{
case "Biologist":
astronaut = new Biologist(astronautName);
break;
case "Geodesist":
astronaut = new Geodesist(astronautName);
break;
case "Meteorologist":
astronaut = new Meteorologist(astronautName);
break;
default:
throw new InvalidOperationException(ExceptionMessages.InvalidAstronautType);
}
astronautRepository.Add(astronaut);
return(string.Format(OutputMessages.AstronautAdded, astronaut.GetType().Name, astronautName));
}
public string AddAstronaut(string type, string astronautName)
{
string message = string.Empty;
IAstronaut astronaut = null;
switch (type)
{
case "Biologist":
astronaut = new Biologist(astronautName);
break;
case "Geodesist":
astronaut = new Geodesist(astronautName);
break;
case "Meteorologist":
astronaut = new Meteorologist(astronautName);
break;
default:
throw new InvalidOperationException(string.Format(ExceptionMessages.InvalidAstronautType));
}
this.astronauts.Add(astronaut);
return(string.Format(OutputMessages.AstronautAdded, type, astronautName));
}
public string AddAstronaut(string type, string astronautName)
{
IAstronaut astronaut = null;
if (type == "Biologist")
{
astronaut = new Biologist(astronautName);
}
else if (type == "Geodesist")
{
astronaut = new Geodesist(astronautName);
}
else if (type == "Meteorologist")
{
astronaut = new Meteorologist(astronautName);
}
else
{
throw new InvalidOperationException("Astronaut type doesn't exists!");
}
astronautRepository.Add(astronaut);
return($"Successfully added {type}: {astronautName}!");
}
public string AddAstronaut(string type, string astronautName)
{
if (type != nameof(Biologist) && type != nameof(Geodesist) && type != nameof(Meteorologist))
{
throw new InvalidOperationException("Astronaut type doesn't exists!");
}
IAstronaut astronaut = null;
if (type == "Biologist")
{
astronaut = new Biologist(astronautName);
}
else if (type == "Geodesist")
{
astronaut = new Geodesist(astronautName);
}
else if (type == "Meteorologist")
{
astronaut = new Meteorologist(astronautName);
}
this.astronautRepository.Add(astronaut);
return($"Successfully added {astronaut.GetType().Name}: {astronaut.Name}!");
}
public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
{
while (true)
{
if (planet.Items.Count == 0)
{
break;
}
IAstronaut astronaut = astronauts.First(a => a.CanBreath);
astronaut.Breath();
astronaut.Bag.Items.Add(planet.Items.First());
planet.Items.Remove(planet.Items.First());
if (astronaut.CanBreath == false)
{
astronauts.Remove(astronaut);
}
if (astronauts.Count == 0)
{
break;
}
}
}
public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
{
while (true)
{
IAstronaut currentAstronauth = astronauts.FirstOrDefault(a => a.CanBreath);
if (currentAstronauth == null)
{
break;
}
while (planet.Items.Count != 0)
{
var currentItem = planet.Items.FirstOrDefault();
currentAstronauth.Breath();
currentAstronauth.Bag.AddItem(currentItem);
planet.RemoveItem(currentItem);
if (!currentAstronauth.CanBreath)
{
break;
}
}
if (planet.Items.Count == 0)
{
break;
}
}
}
public string AddAstronaut(string type, string astronautName)
{
IAstronaut astronautNew = null;
switch (type)
{
case nameof(Biologist):
astronautNew = new Biologist(astronautName);
break;
case nameof(Geodesist):
astronautNew = new Geodesist(astronautName);
break;
case nameof(Meteorologist):
astronautNew = new Meteorologist(astronautName);
break;
default:
throw new InvalidOperationException(ExceptionMessages.InvalidAstronautType);
}
this.astronautRepository.Add(astronautNew);
return(string.Format(OutputMessages.AstronautAdded, type, astronautName));
}
public string AddAstronaut(string type, string astronautName)
{
//if (type != nameof(Biologist) || type != nameof(Geodesist) || type != nameof(Meteorologist))
//{
// throw new InvalidOperationException("Astronaut type doesn't exists!");
//}
IAstronaut astronautNew = null;
string returnMessage = string.Empty;
switch (type)
{
case nameof(Biologist):
astronautNew = new Biologist(astronautName);
returnMessage = $"Successfully added {type}: {astronautName}!";
break;
case nameof(Geodesist):
astronautNew = new Geodesist(astronautName);
returnMessage = $"Successfully added {type}: {astronautName}!";
break;
case nameof(Meteorologist):
astronautNew = new Meteorologist(astronautName);
returnMessage = $"Successfully added {type}: {astronautName}!";
break;
default:
throw new InvalidOperationException("Astronaut type doesn't exists!");
}
this.astronuatRepository.Add(astronautNew);
return(returnMessage);
}
public bool Remove(IAstronaut model)
{
if (this.models.Any(x => x.Name == model.Name))
{
this.models.Remove(model);
return(true);
}
return(false);
}
public string RetireAstronaut(string astronautName)
{
IAstronaut astronaut = this.astronautRepository.FindByName(astronautName);
if (!this.astronautRepository.Remove(astronaut))
{
throw new InvalidOperationException($"Astronaut {astronautName} doesn't exists!");
}
return($"Astronaut {astronaut.Name} was retired!");
}
public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
{
while (true)
{
IAstronaut astronaut = astronauts.FirstOrDefault(x => x.CanBreath == true);
if (astronaut == null)
{
break;
}
var currentItem = planet.Items.FirstOrDefault();
if (currentItem == null)
{
break;
}
astronaut.Breath();
if (astronaut.CanBreath)
{
astronaut.Bag.Items.Add(currentItem);
planet.Items.Remove(currentItem);
}
}
//while (true)
//{
//var astronaut = astronauts.FirstOrDefault(a => a.CanBreath == true);
//if (astronaut == null)
//{
// break;
//}
//if (planet.Items.Count == 0)
//{
// break;
//}
//while (astronaut.CanBreath)
//{
// var item = planet.Items.FirstOrDefault();
// if (item == null)
// {
// break;
// }
// astronaut.Breath();
// if (astronaut.CanBreath)
// {
// astronaut.Bag.Items.Add(item);
// planet.Items.Remove(item);
// }
//}
//}
}
public string RetireAstronaut(string astronautName)
{
IAstronaut wantedAstronaut = this.astronautRepository.Models.FirstOrDefault(a => a.Name == astronautName);
if (wantedAstronaut == null)
{
throw new InvalidOperationException(String.Format(ExceptionMessages.InvalidRetiredAstronaut, astronautName));
}
this.astronautRepository.Remove(wantedAstronaut);
return(String.Format(OutputMessages.AstronautRetired, astronautName));
}
public IAstronaut GetAstronaut(string typeName, string name)
{
var type = Assembly
.GetCallingAssembly()
.GetTypes()
.FirstOrDefault(t => t.Name == typeName);
IAstronaut astronaut = type is null ? null : (IAstronaut)Activator.CreateInstance(type, name);
return(astronaut);
}
public IAstronaut CreateAstronaut(string type, string name)
{
Type astronautType = Assembly
.GetCallingAssembly()
.GetTypes()
.FirstOrDefault(x => x.Name == type);
IAstronaut astronaut = (IAstronaut)Activator
.CreateInstance(astronautType, name);
return(astronaut);
}
public string RetireAstronaut(string astronautName)
{
IAstronaut astronaut = astronautRepository.Models.FirstOrDefault(a => a.Name == astronautName);
if (astronaut == null)
{
throw new InvalidOperationException($"Astronaut {astronautName} doesn't exists!");
}
this.astronautRepository.Remove(astronaut);
return($"Astronaut {astronautName} was retired!");
}
public string RetireAstronaut(string astronautName)
{
if (this.astronautRepository.FindByName(astronautName) == null)
{
throw new InvalidOperationException(string.Format(ExceptionMessages.InvalidRetiredAstronaut, astronautName));
}
IAstronaut astronaut = this.astronautRepository.FindByName(astronautName);
this.astronautRepository.Remove(astronaut);
return(string.Format(OutputMessages.AstronautRetired, astronaut.Name));
}
public string RetireAstronaut(string astronautName)
{
IAstronaut astronaut = this.astronautRepository.FindByName(astronautName);
if (astronaut == null)
{
throw new InvalidOperationException(String.Format(ExceptionMessages.InvalidRetiredAstronaut, astronautName));
}
this.astronautRepository.Remove(astronaut);
return($"Astronaut {astronautName} was retired!");
}
public string RetireAstronaut(string astronautName)
{
IAstronaut astronaut = this.astronauts.FindByName(astronautName);
if (astronaut == null)
{
throw new InvalidOperationException(String.Format(ExceptionMessages.InvalidRetiredAstronaut, astronautName));
}
this.astronauts.Remove(astronaut);
return(String.Format(OutputMessages.AstronautRetired, astronautName));
}
public static void WaitToRemove(int hashcode, IAstronaut astronaut)
{
if (!_astronautDeleted.ContainsKey(hashcode))
{
lock (_syncDelete) {
if (!_astronautDeleted.ContainsKey(hashcode))
{
_astronautDeleted.Add(hashcode, astronaut);
}
}
}
}
public IAstronaut CreateAstronaut(string type, string astronautName)
{
Type astronautType = Assembly.GetCallingAssembly().GetTypes().FirstOrDefault(t => t.Name == type);
if (astronautType == null)
{
throw new InvalidOperationException(ExceptionMessages.InvalidAstronautType);
}
IAstronaut astronaut = (IAstronaut)Activator.CreateInstance(astronautType, astronautName);
return(astronaut);
}
/// <summary>
/// Create a new instance of <see cref="PeriodicAstronaut"/>.
/// </summary>
/// <param name="astronaut"></param>
/// <param name="flushInterval"></param>
public PeriodicAstronaut(IAstronaut astronaut, TimeSpan flushInterval)
{
_astronaut = astronaut ?? throw new ArgumentNullException(nameof(astronaut));
if (_astronaut is IFlushableAstronaut flushable)
{
_timer = new Timer(_ => FlushToDisk(flushable), null, flushInterval, flushInterval);
}
else
{
_timer = new Timer(_ => { }, null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
InternalLogger.WriteLine("{0} configured to flush {1}, but {2} not implemented", typeof(PeriodicAstronaut), astronaut, nameof(IFlushableAstronaut));
}
}
public string RetireAstronaut(string astronautName)
{
IAstronaut astronaut = astronautRepository.FindByName(astronautName);
if (astronaut == null)
{
var message = string.Format(ExceptionMessages.InvalidRetiredAstronaut, astronautName);
throw new InvalidOperationException(message);
}
astronautRepository.Remove(astronaut);
return(string.Format(OutputMessages.AstronautRetired, astronautName));
}
public string RetireAstronaut(string astronautName)
{
IAstronaut astronaut = this.astronauts.FirstOrDefault(a => a.Name == astronautName);
if (this.astronauts.Contains(astronaut))
{
this.astronauts.Remove(astronaut);
return$ "Astronaut {astronautName} was retired!";
}
else
{
throw new InvalidOperationException($"Astronaut {astronautName} doesn't exists!");
}
}
public string RetireAstronaut(string astronautName)
{
IAstronaut toReite = astronauts.FindByName(astronautName);
if (toReite is null)
{
throw new InvalidOperationException($"Astronaut {astronautName} doesn't exists!");
}
else
{
astronauts.Remove(toReite);
return($"Astronaut {astronautName} was retired!");
}
}
