Existen diferentes formas de conseguir eliminar duplicados en una cadena, las formas más sencillas sería utilizar otros métodos como puede ser importar System.Linq la cual nos permite “limpiar” de duplicados con su método Distinct.

Sin embargo como ejercicio para comprender el funcionamiento de los arrays creo que puede ser muy útil hacerlo nosotros mismos, ya que tendremos que ver previamente como saber si un elemento está en un array y como añadir un elemento a un array.

Primer vamos con ¿Cómo saber si un elemento está en un array?

bool LetraEstaEnMatriz(char letra, char[] Letras){
		for (int i = 0; i < Letras.Length; i++) {
			if (letra == Letras [i]) {
				return true;
			}
		}
		return false;
	}

Creamos una función que devuelve un bool y recorremos el array comparando letra a letra, al hacer return si encuentra una letra se sale de la función por lo que no continua el for

La siguiente función a implementar es la que nos añade un elemento a un array , lo normal es añadirlo al final del array, la ventaja de crear nuestra propia función es que podriamos cambiar este orden si quisieramos.

char[] AñadeLetraAMatriz(char letra,char[] Letras){

		//se aumenta la matriz
		char[] Copia_letras=new char[Letras.Length+1];

		for (int i = 0; i < Letras.Length; i++) {
			Copia_letras [i] = Letras [i];

		}
		//queda la ultima
		Copia_letras[Letras.Length]=letra;
		Letras = Copia_letras;
		return Letras;
	}

Un array no permite añadir directamente, lo que hay que hacer es crear una copia previa, dejando un “espacio” para la nueva letra, despues se vuelca todo el array y finalmente se añade la última, volvemos a meter los elementos en el array original con Letras=Copia_letras y finalmente devolvemos el array con las letras

Ahora nos queda la parte final, para eliminar los duplicados, crearemos otra función

char[] SacaLetrasSinRepetir(string _palabra){
		char[] Letras=new char[0];

		for (int i = 0; i < _palabra.Length; i++) {
			for (int j = 0; j < _palabra.Length; j++) {

				if (i != j) {
					if (_palabra [i] == _palabra [j]) {
						if (!LetraEstaEnMatriz (_palabra [i], Letras)) {

							Letras = AñadeLetraAMatriz (_palabra [i], Letras);
						
							break;
						}
					} else {
						if (!LetraEstaEnMatriz (_palabra [i], Letras)) {
							Letras = AñadeLetraAMatriz (_palabra [i], Letras);

						}
					}
				}			
			}

		}
		return Letras;
	}

Primero creamos un array de dimension 0 que esta preparado para ir añadiendo letras, con char[] Letras=new char[0];

Despues recorremos _palabra , aqui hay que tener en cuenta que necesitamos dos bucles anidados para que haga la comparación de una letra con todas las demás.

Si tenemos por ejemplo una cadena “AABB”, lo que debemos hacer es comparar el elemento 0 , es decir A con ABB, despues la segunda A con BB ..

Por eso usamos los dos for, ahora bien una letra siempre será igual a si misma por eso despreciamos el caso i==j quedándonos solo con i!=j

Si la letra coincide es igual a otra, es decir esta repetida, comprobamos que no la tenemos ya en la matriz, con la función LetraEstaEnMatriz (_palabra [i], Letras) como es no , usamos la exclamación para negar el caso quedando

!LetraEstaEnMatriz (_palabra [i], Letras) si entramos en este if significa que no tenemos la letra en Letras por lo que la podemos añadir con la función

Letras = AñadeLetraAMatriz (_palabra [i], Letras); Después tenemos un break; este hace que se salga del primer for, por que ya no necesitamos comprobar más si tenemos una A que es igual a otra la guardamos solo una vez

Nos queda la otra posibilidad que la letra no sea igual, la guardamos en la misma matriz Letras, así tendremos tanto las que se repiten como las que no.

Sólo queda devolver el array que contendrá las letras sin los duplicados con un return

Como siempre digo en mis clases , este es el camino que he elegido yo, no es el único , quizá tu lógica te lleve por otro hasta es posible que el código se pueda optimizar más, para eso debes buscar tu propio camino.