Métodos dentro de una clase

Como recomendación al profe Miguel, para estos temas educativos es mucho más fácil para uno como estudiante entender si en lugar de poner cosas como:

var item in SuperPoderes

Pones:
var poder in SuperPoderes

Obviamente es lo mismo porque solamente es una variable, pero es mucho más fácil de entender para quien lee el código si ponemos un nombre que corresponda al objeto que vamos a iterar, en lugar de poner algo genérico como “item”.

💡 Esta imagen ilustra muy bien la diferencia entre clases, objetos, atributos y métodos:

using System.Text;

FinishAttack elephantGun = new FinishAttack();
elephantGun.Name = "Elephant Gun";
elephantGun.Description = "Giant fist wrapped in weaponry haki";
elephantGun.Damage = 200.5;

FinishAttack redHawk = new FinishAttack();
redHawk.Name = "Red Hawk";
redHawk.Description = "Rubber Fist wrapped in weaponry haki and fire";
redHawk.Damage = 280.5;

DevilFruit gomugomu = new DevilFruit();
gomugomu.Name = "Gomu Gomu No Mi";
gomugomu.Description = "The User have the complex of rubber and in his awakening converts into Nika God";
gomugomu.Type = TypeDevilFruit.Zoan;

OnePieceCharacter luffy = new OnePieceCharacter();
luffy.Name = "Monkey D. Luffy";
luffy.Description = "Future King of Pirates";
luffy.Occupation = Occupation.Pirate;
luffy.HaveFruit = true;
luffy.Fruit = gomugomu;
luffy.FinishAtacks.Add(elephantGun);
luffy.FinishAtacks.Add(redHawk);

string infoLuffy = luffy.GetInfo();

Console.WriteLine("ONE PIECE GAME:");
Console.WriteLine(infoLuffy);

class OnePieceCharacter
{
    public int Id;
    public string Name;
    public string Description;
    public Occupation Occupation;
    public bool HaveFruit;
    public DevilFruit? Fruit;
    public List<FinishAttack> FinishAtacks;
    public double Life;

    public OnePieceCharacter()
    {
        Id = 1;
        Occupation = Occupation.Civil;
        FinishAtacks = new List<FinishAttack>();
        Life = 1000d;
        HaveFruit = false;
        Fruit = null;
    }

    public string GetInfo()
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendLine($"Nombre: {Name}");
        sb.AppendLine($"Descripcion: {Description}");
        sb.AppendLine($"Ocupacion: {Occupation}");
        if (Fruit != null)
        {
            sb.AppendLine($"Fruta del diablo: {Fruit?.Name}");
        } else
        {
            sb.AppendLine($"Fruta del diablo: No tiene");
        }
        foreach (var atack in FinishAtacks)
        {
            sb.AppendLine($"Ataque: {atack.Name}  ->  {atack.Damage} damage");

        }

        return sb.ToString();
    }
}


class DevilFruit
{
    public string Name;
    public string Description;
    public TypeDevilFruit Type;

    public DevilFruit()
    {
        Type = TypeDevilFruit.Paramecia;
    }
}

enum Occupation
{
    Civil,
    Pirate,
    Marine,
    Revolutionary
}
enum TypeDevilFruit
{
    Paramecia,
    Zoan,
    Logia
}

class FinishAttack
{
    public string Name;
    public string Description;
    public double Damage;

    public FinishAttack()
    {
        Damage = 10d;
    }
}

Métodos dentro de una clase en C# POO:

En resumen:

• Los métodos son acciones que una clase puede realizar.

• Se definen dentro de la clase con una estructura similar a una función.

• Permiten encapsular funcionalidad y reutilizarla.

• Pueden tener diferentes tipos de acceso (public, private, etc.)

• Pueden tener parámetros para recibir datos y devolver valores.

Ejemplo:

public class Persona
{
    public void Saludar()
    {
        Console.WriteLine("Hola!");
    }

    public string ObtenerNombre(string nombre)
    {
        return nombre;
    }
}

Beneficios:

• Modularidad: Dividen el código en partes más pequeñas y manejables.

• Reutilización: Permiten usar la misma funcionalidad en diferentes partes del código.

• Encapsulamiento: Ocultan detalles de implementación y solo exponen la funcionalidad necesaria.

Debe publicar en el curso el codigo que va implementando, para poder copiarlo o comparar con lo que uno transcribe, y sea de ayuda

string resultSuperPoderes = superma.UsarSuperPoderes();
Console.WriteLine(resultSuperPoderes);

StringBuilder es una clase en C# que se utiliza para representar una cadena de caracteres mutable. A diferencia de las cadenas de caracteres normales (string) en .NET, que son inmutables, StringBuilder permite modificar el contenido de la cadena sin generar una nueva instancia de cadena cada vez que se realiza una modificación. Esto lo hace especialmente útil para operaciones que requieren cambios frecuentes en el contenido de la cadena, como la concatenación repetida, porque mejora el rendimiento al reducir la cantidad de objetos string innecesarios creados en la memoria.

Este código crea un StringBuilder, le añade algunas líneas de texto utilizando AppendLine y luego imprime el resultado final.

<code> 
using System;
using System.Text;

class Program
{
    static void Main()
    {
        // Crear una instancia de StringBuilder.
        StringBuilder sb = new StringBuilder();

        // Añadir algunas líneas de texto.
        sb.AppendLine("Primera línea.");
        sb.AppendLine("Segunda línea.");
        sb.AppendLine("Tercera línea.");

        // También se puede añadir texto sin un salto de línea al final.
        sb.Append("Final sin salto de línea.");

        // Convertir el StringBuilder a string y mostrar el resultado.
        string resultado = sb.ToString();
        Console.WriteLine(resultado);
    }
}

se crea un objeto StringBuilder llamado sb. Luego, se utiliza el método AppendLine para añadir tres líneas de texto a sb, cada una seguida de un salto de línea. Después, se añade una línea sin salto de línea al final usando el método Append. Finalmente, se convierte el contenido de sb a un string usando el método ToString y se imprime en la consola.

La salida del programa sería:

<code> 
Primera línea.
Segunda línea.
Tercera línea.
Final sin salto de línea.