Come faccio a rappresentare un HSL e un colore RGB come una classe in C #?

Question

Come avrei scritto una classe in C # che rappresenta un colore HSL e un colore RGB?

Una volta che ho questo, è possibile aggiungere un metodo che stampa ciascuno degli attributi di classe? Ho sentito parlare di ToString(), ma non sono sicuro di come usarlo.

Un codice d'esempio sarebbe molto utile, in quanto io sono uno studente e cercando di imparare come utilizzare C #. Grazie!

Answer 1

La gente si infastidito quando si posta "domande" chiedendo ad altri di scrivere il codice per voi. Un sacco di domande da nuovi utenti sembrano per chiedere questo, e la vostra persino lo fa esplicitamente . Speriamo che spiega alcune delle reazioni negative che hai incontrato da altri utenti, sia in downvoting, il voto al vicino, o addirittura eliminando le vostre domande. Spero che questo non ti ha dato una tale esperienza negativa qui che si sta guidato via. In futuro, ci si accorge che le persone sono molto più disposti ad aiutarvi se si mostra alcune prove di aver cercato di aiutare se stessi per primi. Mostraci un codice che avete scritto (ma non funziona), o suggerire alcuni modi possibili che hai provato a risolvere il problema da soli. La maggior parte delle domande non sono "troppo banale", ma le domande piuttosto non reale. Non siamo un codice di servizio di scrittura, ma siamo ancora felice di aiuto.

Detto questo, cercherò di continuare in realtà rispondendo alla domanda come ho fatto in un commento. Se non altro perché amo domande di codifica che si occupano di colore e lo spazio colore conversioni. La questione di come per la conversione tra spazi colore è già stato chiesto e ha risposto più volte qui su SO. Per esempio, io (e molti altri) fornito un algoritmo (in diverse lingue) qui . Dovrebbe essere semplice per convertire uno di questi a qualunque lingua selezionata.

Per quanto riguarda il "come faccio a scrivere una classe per rappresentare i valori in quegli spazi colore", che è abbastanza semplice. Una ricerca di Google avrebbe anche alzato diversi risultati di persone che avevano già fatto la stessa cosa. Personalmente, vi consiglio di creare un struttura , piuttosto che una classe, perché è un molto leggero valori dell'oggetto e il colore sono immutabili (nel senso che non cambiano). Questa è una misura perfetta per una struttura, e se vuoi di più spiegazione della differenza, è possibile trovare che domanda ha già stato chiesto e risposto anche qui ben .

Ma a seconda di quale si sceglie, il risultato finale è molto simile. Presumo che se questo è per una classe di programmazione, hai già stato insegnato tutto quello che dovete sapere per essere in grado di farlo da soli. Significato, dovreste aver già imparato a conoscere campi privati ??(variabili membro), le proprietà pubbliche e metodi. Inizierete con la creazione di una struttura con 3 campi privati ??per rappresentare ciascuno dei valori di colore; Tonalità (H), saturazione (S), e la luminosità (L). Essi dovrebbero probabilmente ogni essere di tipo Integer, perché i singoli valori di colore sono numeri interi compresi tra 0 e 100, o 0 e 360. Se si importasse la massima precisione, è possibile memorizzare come tipo Decimal e gestire la conversione al Integer nel pubblico proprietà che li espongono al mondo, ma dubito questo è necessaria qui. In entrambi i casi, sarà il prossimo bisogno di creare quelle proprietà pubbliche che espongono i vostri campi privati ??al mondo. Questo è un concetto base nella programmazione orientata agli oggetti, e non deve essere uno che è una novità per voi. (Se lo è, si ha realmente bisogno di fermarsi ora e ottenere un libro che spiega OOP a voi. Non passare Go, non raccolgono di $ 200.) Le proprietà pubbliche devono essere di tipo Integer, ci dovrebbe essere 3 di loro per ciascuna delle i valori dei componenti del colore individuale, e che dovrebbero (almeno se si sta creando una struttura immutabile) essere di sola lettura (includere solo un getter, non un setter). Qualcosa di simile a questo:

/// <summary>
/// Represents an HSL color, composed of individual
/// Hue, Saturation, and Lightness attributes.
/// </summary>
public struct HSLColor
{
    private int _hue;
    private int _saturation;
    private int _lightness;

    /// <summary>
    /// The hue attribute of the color.
    /// (This is a value, in degrees, from 0 to 360.)
    /// </summary>
    public int Hue
    {
        get { return _hue; }
    }

    /// <summary>
    /// The saturation attribute of the color.
    /// (This is a percentage between 0 and 100.)
    /// </summary>
    public int Saturation
    {
        get { return _saturation; }
    }

    /// <summary>
    /// The lightness attribute of the color.
    /// (This is a percentage between 0 and 100.)
    /// </summary>
    public int Lightness
    {
        get { return _lightness; }
    }
}

Infine, si dice è necessario eseguire l'override del metodo ToString. Come dovreste aver già appreso, questo miThOD è fornita da ogni classe in .NET Framework perché è ereditato dalla Object base. Naturalmente, è contrassegnato come virtual, che permette di ignorare e fornire la propria implementazione. La parte più difficile è capire qual è il suo valore di ritorno dovrebbe essere simile. Si può scegliere di rappresentare il colore come una triade, mostrando le sue tre valori dei singoli componenti. Indipendentemente da ciò, è necessario utilizzare il metodo di String.Format , che permette di creare una stringa tra cui "elementi formato" che vengono sostituiti dal valore dell'oggetto corrispondente. Ad esempio, ecco come lo faccio:

/// <summary>
/// Returns the "(HH, SS, LL)" representation of this HSLColor structure.
/// </summary>
public override string ToString()
{
    return string.Format("({0}, {1}, {2})",
                         this.Hue,
                         this.Saturation,
                         this.Lightness);
}

Questo dovrebbe essere sufficiente per iniziare. I molto incoraggio a non basta copiare e incollare il codice fornito qui come la vostra assegnazione. Non stai imparando nulla in questo modo. Accendi il vostro IDE, scrivere il codice da soli, e provare un paio di diverse varianti. Assicurati di comprendere come funziona, quello che ho fatto, e come si potrebbe fare di nuovo da soli. Buona fortuna!