Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

[Unity / C#] Hashtable - Dokumentationskommentare und Parsing

  • 1
  • 2

Werbeanzeige

Renegade

Alter Hase

  • »Renegade« ist der Autor dieses Themas

Beiträge: 494

Wohnort: Berlin

Beruf: Certified Unity Developer

  • Private Nachricht senden

1

19.01.2014, 16:47

[Unity / C#] Hashtable - Dokumentationskommentare und Parsing

Hey Leute,

1. Gibt es eine übersichtliche Möglichkeit für die Dokumentationskommentare bei Hashtables? Leider weiß ich mir nicht besser zu helfen als folgendes:

C#-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

    /// <summary>
    /// Register a Key with a specific Keycode
    /// </summary>
    /// <param name="target">the target is the the GameObjecte where the SendMessage goes to</param>
    /// <param name="code">the specific Keycode</param>
    /// <param name="args">
    /// "down" - Callback Method Name for GetKeyDown
    /// "up" - Callback Method Name for GetKeyUp
    /// "auto" - Callback Method Name for GetKey
    /// </param>
    /// <returns>Keydata for Bookkeeping or Deregistration</returns>
    public KeyData RegisterKey(GameObject target, KeyCode code, Hashtable args) {
        KeyData key = new KeyData(target, code, args);
        _keys.Add(key);
        return key;
    }


2. Gibt es Best Practices für das Parsen von Hashtables? Meine aktuelle Lösung finde ich sehr unschön:

C#-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public void Update() {
        foreach (KeyData key in _keys) {
            if (key.code != KeyCode.None) {
                //Keys with keycode
                if (key.args.ContainsKey("down")) {
                                    ///...
                }
                if (key.args.ContainsKey("up")) {
                                    ///...
                } 
                if (key.args.ContainsKey("auto")) {
                                    ///...
                }
            } else {
                //Keys with names
                if (key.args.ContainsKey("down")) {
                                    ///...
                } 
                if (key.args.ContainsKey("up")) {
                                    ///...
                }
                if (key.args.ContainsKey("auto")) {
                                    ///...
            }
            if (key.args.ContainsKey("auto") == false && key.args.ContainsKey("down") == false && key.args.ContainsKey("up")) {
                Debug.LogError("The key: " + key.name + " with target: " + key.target + " has no callback methods!");
            }
        }
}
Liebe Grüße,
René

equinox

Frischling

Beiträge: 56

Beruf: Student

  • Private Nachricht senden

2

19.01.2014, 17:35

Für den ersten Fall, tun es da nicht auch Enumartions?

Renegade

Alter Hase

  • »Renegade« ist der Autor dieses Themas

Beiträge: 494

Wohnort: Berlin

Beruf: Certified Unity Developer

  • Private Nachricht senden

3

19.01.2014, 17:55

Zitat von »equinox«

Für den ersten Fall, tun es da nicht auch Enumartions?


Ich kann dir nicht ganz folgen?! Beziehst du dich auf die Dokumentationskommentare?
Liebe Grüße,
René

Sacaldur

Community-Fossil

Beiträge: 2 301

Wohnort: Berlin

Beruf: FIAE

  • Private Nachricht senden

4

19.01.2014, 19:35

Zitat von »Renegade«

Zitat von »equinox«

Für den ersten Fall, tun es da nicht auch Enumartions?


Ich kann dir nicht ganz folgen?! Beziehst du dich auf die Dokumentationskommentare?

Wahrscheinlich will er darauf hinaus, dass statt der Strings als Schlüssel auch eine Enumeration verwendet werden kann, bei der man dann sicher sein kann, dass ein entsprechender Wert auch gültig ist.

Etwas anderes:
Sind die Werte für dich überhaupt von irgendeiner Relevanz? (In dem Code, den du hier gepostet hast, sieht man nur Prüfungen der Schlüssel.) Sollte das Nicht der Fall sein, dann könntest du alternativ eine beliebige Sammlung (Arrays, IList, ...) stattdessen verwenden.
Hat es einen bestimmten Grund, warum du überhaupt eine Auflistung von "Events" ("up", "down" und/oder "auto) mit einer bestimmten Taste kombinierst und nicht eher mehrere Kombinationen statt dessen machst? (Die Register-Methode würde also keine Hashtable erhalten, sondern einen einzelnen Wert.)
Spieleentwickler in Berlin? (Thema in diesem Forum)
---

Zitat von »Jonathan_Klein«

Es ist ja keine Schande etwas falsch zu machen, als Programmierer tu ich das täglich, [...].

Renegade

Alter Hase

  • »Renegade« ist der Autor dieses Themas

Beiträge: 494

Wohnort: Berlin

Beruf: Certified Unity Developer

  • Private Nachricht senden

5

19.01.2014, 19:54

Zitat von »Sacaldur«

Wahrscheinlich will er darauf hinaus, dass statt der Strings als Schlüssel auch eine Enumeration verwendet werden kann, bei der man dann sicher sein kann, dass ein entsprechender Wert auch gültig ist.


Nun ich habe mich bei dem Konzept stark an iTween orientiert und wollte einen ähnlichen Workflow übernehmen und habe erst einmal noch nicht hinterfragt warum Bob ausschließlich string als Key benutzt. (Siehe Dokumentation von iTween z.B. bei MoveTo)

Zitat von »Sacaldur«

Sind die Werte für dich überhaupt von irgendeiner Relevanz?


Ja! Ich hatte gehofft es geht aus dem Code hervor, aber das Value ist in den gezeigten Fällen die Callback Methode. Es existieren ebenfalls Möglichkeiten wie "delay" oder "frequency", welche als Value float entgegen nehmen.
Hier mal ein Beispiel:

C#-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Player : GoodBehaviour {
    
    void Start () {
        //Registriert den Key P und setzt die Methoden Down und Up als Callback für die Ereignisse Input.GetKeyDown und Input.GetKeyUp und prüft diese mit einer Frequenz von 0.1s
        InputManager.RegisterKey(gameObject, KeyCode.P, Extensions.Hash("down", "DownMethode", "up", "UpMethode","frequency",0.1f));
    }

    void DownMethode() {
        Debug.Log("Taste P geht runter");
    }

    void UpMethode() {
        Debug.Log("Taste P geht hoch");
    }
}


Ich wollte im Eingangspost lediglich die Prüfung zeigen, weil sich meine Frage nach dem Best Practices ausschließlich auf die Behandlung aller Hashtable-Keys bezieht. Ich hatte gehofft, es existiert ein gängiger Algorithmus oder Design für das Problem.
Liebe Grüße,
René

Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von »Renegade« (19.01.2014, 20:08)

TrommlBomml

Community-Fossil

Beiträge: 2 117

Wohnort: Berlin

Beruf: Software-Entwickler

  • Private Nachricht senden

6

20.01.2014, 07:47

Ich habe so etwas auch schonmal in etwa implementiert. Du hast ja ein ähnliches Problem, wenn du selber eine InputBox oder TextBox implementieren möchtest. Ich hatte jedoch den Vorteil, dass ich mir alle KeyCodes als String in eine Liste tun konnte, dann kannst du das ziemlich einfach zusammenfassen denke ich.

Renegade

Alter Hase

  • »Renegade« ist der Autor dieses Themas

Beiträge: 494

Wohnort: Berlin

Beruf: Certified Unity Developer

  • Private Nachricht senden

7

20.01.2014, 15:03

Beziehst du dich dabei auf die KeyCodes von Unity oder auf die Keys im Hashtable?
Wenn du die Keys im Hashtable meinst, wie würdest du die passend zusammenfassen?

PS: Mit den Dokumentationskommentaren kennt sich wohl keiner aus :( ?
Liebe Grüße,
René

TrommlBomml

Community-Fossil

Beiträge: 2 117

Wohnort: Berlin

Beruf: Software-Entwickler

  • Private Nachricht senden

8

20.01.2014, 18:11

Eher Unity würd ich sagen. Die Struktur mit Key.args ist halt doof, weil du alles einzeln prüfen müsst. Wenn jedoch Keys.args ein IEnumerable ist, kann man ein bisschen was zusammenfassen. Oder ist die Klasse von dir?

Zu den Xml-Kommentaren: Nein, das geht nicht übersichtlicher. Das hast du doch schon ziemlich gut gemacht :)

Renegade

Alter Hase

  • »Renegade« ist der Autor dieses Themas

Beiträge: 494

Wohnort: Berlin

Beruf: Certified Unity Developer

  • Private Nachricht senden

9

20.01.2014, 19:13

Zitat von »TrommlBomml«

Eher Unity würd ich sagen. Die Struktur mit Key.args ist halt doof, weil du alles einzeln prüfen müsst. Wenn jedoch Keys.args ein IEnumerable ist, kann man ein bisschen was zusammenfassen. Oder ist die Klasse von dir?


Eher Unity - was?!
Welche Klasse meinst du jetzt? args ist ein Hashtable.
Wie würdest du das zusammenfassen?
Liebe Grüße,
René

TrommlBomml

Community-Fossil

Beiträge: 2 117

Wohnort: Berlin

Beruf: Software-Entwickler

  • Private Nachricht senden

10

20.01.2014, 19:35

Ah ok das macht einiges klarer :) Was passiert denn in den If-Statements? Wie gesagt, du kannst dann wenn du willst dictionaries<string, Action> anlegen. In etwa so:

C#-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

private Dictionary<string, Action<bool>> _actionsPerKey = new Dictionary<string, Action<bool>>
{
    { "down", b => DoSomethingUpMethod(b) },
    { "up", b => DoSomethingDownMethod(b) },
};

public void Update() 
{
    foreach (KeyData key in _keys) 
    {
        foreach(var keyNameAsString in key.args.Keys)
        {
            _actionsPerKey[keyNameAsString ].invoke(key.code != KeyCode.None);
        }
        if (key.args.ContainsKey("auto") == false && key.args.ContainsKey("down") == false && key.args.ContainsKey("up")) {
            Debug.LogError("The key: " + key.name + " with target: " + key.target + " has no callback methods!");
        }
    }
}


Es kommt auf stark drauf an, was du in den If-statements tust, um dir sagen zu können, wie man das zusammenfassen kann. Ich habe hier delegaten mit bool-Werte genommen, wenn ein Keycode reinkam oder nicht. Dadurch wird die methode schön kurz.

Werbeanzeige

  • 1
  • 2

Ähnliche Themen