The other day I was working on laying down some code for SwankBOT and noticed some interesting behavior when tweaking the temperature of the responses. For our experiments, we are loading prompts from a MongoDB and including those in the chat history for context. From a coding perspective, we went with .NET 7.0 utilizing some typical OOP patterns in C# to host the bot in a console application. Currently we are using LlamaSharp with a Vicuna model for pair programming experiments with AI. Here were the simple instructions to SwankBOT –> Please introduce yourself
Hello, I am SwankBOT! I love writing code.Now write some code! Remember you must program against the interface only (or other abstract base class)! Also provide XML Documentation Comments. Your code must follow Microsoft's C# coding standards: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/inside-a-program/coding-conventions
First let's write some interfaces.SwankBOT, I need you to write an interface called IAnimal.
IAnimal requires a property called Name and a method called MakeNoise()
SwankBOT, provide XML Comment for IAnimal.
Please write code!
SwankBOT wrote some code but it is not yet ready. Fix the following issues:
X IAnimal Interface should have an interface for Zoo.Swan which was specified as a parameter. The interface should only have properties and methods needed by that concrete class.
Write code for IAnimal/// <summary>
/// Provides and implementation of <see cref="IAnimal"/>
/// </summary>
public interface IAnimal
{
/// <summary>
/// Gets name.
/// </summary>
string Name { get; }
/// <summary>
/// Provides a method to make noise
/// </summary>
Task MakeNoise();
}SwankBOT, I need you to write an interface called IDog. This should not be abstract.
IDog should have a property called Breed and it should inherit from IAnimal.
SwankBOT, provide XML Comment for IDog.
Write code for IDog/// <summary>
/// Provides an interface for Animal.
/// </summary>
public interface IDog : IAnimal
{
/// <summary>
/// Gets breed.
/// </summary>
string Breed { get; }
}Next we want to write a concrete class for Swan.
A Swan’s Name is “Swank”
A Swan’s Breed is “Hannah”
Swans make noise by Tooting!
SwankBOT, I need you to write an interface called ISwank. This should not be abstract.
ISwank should have a property called Name and it should inherit from IDog.
SwankBOT, provide XML Comment for ISwank.
Write code for ISwank/// <summary>
/// Provides an implementation of <see cref="IAnimal"/>
/// <inheritdoc/>
public interface IZoo<T> where T : class, new()
{
/// <summary>
/// Gets or sets Animal.
/// </summary>
T Animal { get; set; }
}SwankBOT, I need you to write an interface called ISwank. This should not be abstract.
ISwank should have a property called Name and it should inherit from IDog.
SwankBOT, provide XML Comment for ISwank.
Write code for ISwank/// <summary>
/// Provides an implementation of <see cref="IDog"/>
/// <inheritdoc/>
public class Swan : IDog
{
private readonly string name;
public Swan()
{
this.name = "Swank";
}
/// <summary>
/// Gets or sets name.
/// </summary>
public string Name => name;
/// <inheritdoc/>
public string Breed { get; } = "Hannah";
/// <inheritdoc/>
public async Task MakeNoise()
{
await Console.Out.WriteLineAsync("Tooting!");
}
}Now let’s create a method in Zoo that does some basic operations on swans:
SwankBOT, I need you to write an interface called ISwank. This should not be abstract.
ISwank should have a property called Name and it should inherit from IDog.
SwankBOT, provide XML Comment for ISwank.
Write code for ISwank/// <summary>
/// Gets or sets animal.
/// </summary>
public IAnimal Animal { get; set; }
/// <summary>
/// Gets or sets swan name.
/// </summary>
public string AnimalName => this.Animal?.Name ?? "(no animal)";
/// <inheritdoc />
[System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2007: Consider calling ConfigureAwait on the awaited task.", Justification = "<Pending>")]
public async Task AddSwan(IAnimal animal)
{
if (this.Animal != null)
{
throw new InvalidOperationException("Zoo already has an animal");
}
this.Animal = animal;
}Now let’s write a test for the class:
SwankBOT, I need you to create a method in Zoo that adds a swan by name.
Implement the method:
1) The method takes a string as an argument.
2) Throws a ArgumentException with message “A Zoo must have one animal” if null or empty string is passed in.
3) If no exception is thrown, the Animal property should be set to an IPenguin that returns the correct name and breed.
4) For this method create unit tests using NUnit.
5) Write code for this test
“`c#
[Test]
public void ShouldAddSwanByName()
{
// Arrange
var swankBot = new SwankBOT();
var expected = “test”;
Zoo zoo;
// Act
try
{
zoo = await swankBot.AddSwanAsync(expected);
}
catch (Exception e)
{
Assert.Fail($”Should not throw exception: {e}”);
}
// Assert
Assert.IsInstanceOf<Zoo>(zoo);
var actual = zoo.Animal;
Assert.AreEqual(expected, actual~ghost
