class MyGene : IGene {

    public int Value;
    
    public MyGene(int value) {
        Value = value;
    }
    
} 

class MyChromosome : IChromosome {

    public double? Fitness { get; set; }
    
    public int Length { get; }
    
    public int[] Values;

    public MyChromosome(int[] values) {
        Values = values;
        Length = Values.Length;
    }

    public IChromosome Clone() {
        var chromosome = new MyChromosome(Values);
        chromosome.Fitness = Fitness;
        return chromosome;
    }

    public void SetGene(int index, IGene gene) {
        Values[index] = ((MyGene)gene).Value;
    }

    public IGene GetGene(int index) {
        return new MyGene(Values[index]);
    }
    
}

class MyFitness : IFitness {

    public double CalculateFitness(IChromosome chromosome) {
        var myChromosome = (MyChromosome) chromosome;
        int counter = 0;
        // for example count how many neighbout numbers differ by only 1
        for (int i = 0; i < myChromosome.Length - 1; i++) {
             if (Math.Abs(myChromosome.Values[i] - myChromosome.Values[i + 1]) == 1) {
                 counter++;
             }
        }
        return counter;
    }

}

class MyChromosomeValidator : IChromosomeValidator {

    public bool Validate(IChromosome chromosome) {
        var myChromosome = (MyChromosome) chromosome;
        // some validation logic here
        return true;
    }

}

class MyChromosomeFactory : IChromosomeFactory, IGeneFactory {

    private int count;
    
    private int maxValue;
    
    private int minValue;
    
    private Random random;

    public MyChromosomeFactory(int count, int minValue, int maxValue, Random random) {
        this.count = count;
        this.minValue = minValue;
        this.maxValue = maxValue;
        this.random = random;
    }
    
    private int GenerateGene(int index) {
        return random.Next(minValue, maxValue);
    }

    public IGene CreateGene(int index) {
        return new MyGene(GenerateGene(index));
    }

    public IChromosome CreateChromosome() {
        var values = new int[count];
        for (int i = 0; i < count; i++) {
            values[i] = GenerateGene(i);
        }
        return new MyChromosome(values);
    }
    
}

var chromosomeFactory = new MyChromosomeFactory(10, -5, 5, new Random());
var geneFactory = chromosomeFactory;

var options = new GeneticAlgorithmOptions {

    // factory that will be used for creating new chromosomes
    ChromosomeFactory = chromosomeFactory,

    // number of chromosomes in generation
    GenerationSize = 20,

    // chance that selected parent will be crossed to create new chromosomes
    CrossoverProbability = 0.8,

    // chance that chromosomes created by crossover will be mutated
    MutationProbability = 0.1,

    // how long continue to run algorithm if best chromosome fitness is not changing
    // [optional]
    // default value: 50
    TerminateUnchangedGenetarionsCount = 50,

    // fitness function
    Fitness = new MyFitness(),

    // selection operator
    Selection = new EliteSelection(),
    // Selection = new RouletteWheelSelection(new Random()),
    // Selection = new TournamentSelection(new Random(), roundSize: 3),

    // parent selection operator
    ParentSelection = new RandomParentSelection(new Random()),
    // ParentSelection = new InbreedingParentSelection(new Random()),

    // crossover operator
    Crossover = new SinglePointCrossover(chromosomeFactory, new Random()),
    // Crossover = new MultiPointCrossover(chromosomeFactory, new Random(), pointsCount: 3),

    // mutation operator
    Mutation = new RandomMutation<MyGene>(geneFactory, new Random()),
    // Mutation = new SwapMutation<MyGene>(new Random()),
    // Mutation = new ReverseMutation<MyGene>(new Random()),

    // [optional]
    // default value: EmptyValidator
    Validator = new MyChromosomeValidator(),

    // delegate function (event) that will be executed after each algorithm iteration
    // [optional]
    OnAfterIteration = (generation) => {
        // output generation chromosomes for example
    }

};

// creting genetic algorithm
ga = new GeneticAlgorithm(options);

// alowed to set after iteration delegate from here also
ga.OnAfterIteration += (generation) => {
    // ...
};

// running algorithm
ga.Run();

// getting result
int generationsCount = ga.GenerationsCount;
var bestChromosome = (MyChromosome) ga.BestChromosome;