Samstag, Januar 25, 2020

Variable Rückgabetyp einer Methode in C#

Ich möchte ein parameter zu einer Methode, und ich möchte, dass meine Methode zum zurückgeben von Daten, indem der parameter. Daten vom Typ boolean, string, int oder etc. Wie kann ich den return-Typ einer Variablen von einer Methode? Ich will nicht, um ein Objekt wieder geben und dann warf es in einen anderen Typ. Zum Beispiel:

BlaBla VariableReturnExampleMethod(int a)
{
    if (a == 1)
        return "Demo";
    else if (a == 2)
        return 2;
    else if (a == 3)
        return True;
    else
        return null;
}

Der Grund, warum ich wollen, das ist, ich habe eine Methode, die liest eine ausgewählte Spalte einer Zeile aus der Datenbank. Arten von Spalten sind nicht gleich, aber ich muss zurück, jede Spalte die Informationen.

InformationsquelleAutor sanchop22 | 2012-05-08

6 Kommentare

  1. 16

    Wie kann ich den return-Typ einer Variablen von einer Methode? Ich will nicht, um ein Objekt wieder geben und dann warf es in einen anderen Typ.

    Gut, dass ist im Grunde, was Sie tun zu tun haben. Alternativ, wenn Sie mit C# 4 können Sie den Rückgabetyp dynamic, die es erlauben die Konvertierung implizit:

    dynamic VariableReturnExampleMethod(int a)
    {
        //Body as per question
    }
    
    ...
    
    //Fine...
    int x = VariableReturnExampleMethod(2);
    
    //This will throw an exception at execution time
    int y = VariableReturnExampleMethod(1);

    Du im Grunde Angabe von Typen zu lassen, die compiler wissen, was zu erwarten ist. Wie kann das funktionieren, wenn der Typ ist nur bekannt Ausführung Zeit? Der Grund, warum die dynamic version funktioniert, ist, dass es im Grunde sagt der compiler zu verschieben, seine normale Arbeit bis Ausführung Zeit – so verlieren Sie die normale Sicherheit, welche lassen würde im zweiten Beispiel wird nicht kompilieren.

    • Ich weiß nicht, ich warte auf Eure Ratschläge.
    • Es ist schwer zu geben, mehr Beratung, ohne zu wissen, warum Sie wollten, dies zu tun in den ersten Platz.
    • Ich mag es, wie Jon Skeet Antwort hatte drei +1s innerhalb von 1 minute beantworten – noch bevor er ausgearbeitet. Muss schön sein 🙂
    • Reizt mehr wie 🙂 ich glaube nicht, dass er sieht den nutzen von den meisten +1s bekommt er an einem Tag, erreicht die max ist eine Menge, so weit wie ich gehört habe.
    • lassen Sie sich nicht von Jon hören, oder, dass die nächsten Rechner-crash nicht ein überbleibsel aus dem Jahr 2002…
  2. 4

    Verwenden dynamic – Schlüsselwort anstelle von BlahBlah wenn Sie auf .Net 4.0 aber wenn weniger dann object ist Ihre sicherste Wette, denn es ist die Basisklasse für jede andere Klasse die man sich denken kann.

  3. 2

    Es klingt wie kann dies eine gute Falle für Generika. Wenn Sie wissen, welchen Datentyp Sie erwarten, wenn Sie es nennen, Sie nennen können, die insbesondere die generische version der Funktion.

    • Obwohl Generika kann helfen, in anderen Situationen, wird es nicht helfen, in der situation zur Verfügung gestellt von der OP es sei denn der Aufrufer kennt die Art soll zurückgegeben werden, indem das bereitgestellte argument zur compile-Zeit… unwahrscheinlich.
    • Houldsworth – auf der Grundlage seiner Beschreibung des Problems (die Tatsache, dass dies ein Aufruf, die zurückgegeben Werte aus einer Datenbank), schien es, wie der aufrufende code kann wirklich wissen, was Sie erwartet. Es klingt, vielleicht hat er eine ReadFromDatabase(fieldname) – Funktion, und würde Sie wahrscheinlich wirklich wissen, den Datentyp des Feldes, in diesem Fall. Das ist kein gutes design, meiner Meinung nach, aber die Generika würden es einfacher machen.
    • Betrachten Field<T> aus DataTable als ein Beispiel dafür. Die einzige gute Optionen sind dieser oder Rückgabe nur Objekt, und als OP ausgeschlossen, die andere option, das ist das, was bleibt.
    • Vereinbart, aber das entfernen der option von casting erweitern kann, so etwas wie dieses. Es hängt wirklich, was der aufrufende code aussieht und was der beabsichtigten Verwendung ist danach. Die Verwendung von Generika bewegt gerade die casting-innerhalb der Methode, der Anrufer muss noch den Staat geben.
  4. 2

    Verwenden Sie so etwas wie Dapper-dot-net (geschrieben von Marc Gravell und Sam Safran in unserer eigenen Stack-Overflow) zu ziehen Dinge aus der DB. Es behandelt die Datenbank-zu-Objekt mapping für Sie.

    Außerdem, wenn Sie nicht wollen, ein Werkzeug zu verwenden, und Sie ziehen aus einer Datenbank, und Sie wissen, dass die Datentypen der verschiedenen Spalten zur compile-Zeit (wie das klingt, werden Sie tun), Sie sollten wahrscheinlich zeilenweise statt spaltenweise.

    //Pseudo-code:
    List<DatabaseObject> objects = new List<DatabaseObject>();
    foreach(var row in DatabaseRows)
    {
        var toAdd = new DatabaseObject();
        toAdd.StringTypeVariable = "Demo";
        toAdd.IntTypeVariable = 2;
        toAdd.BoolTypeVariable = true;
        object.Add(toAdd);
    }

    Hinweis: Sie können mithilfe des Objekt-Initialisierer-syntax und linq hier, aber dies ist die grundlegende Art, wie ich denken konnte, demonstrieren diese ohne eine Tonne zusätzliche Sachen.

    Beachten Sie auch, dass hier ich gehe davon aus, dass Sie nicht eigentlich zurückkehren wollen „Demo“, 2, true, aber die Werte in der Zeile. Das bedeutet nur, Sie würde ändern Sie die hart codierte Werte: row.GetStringType(stringColumnIdx) oder etwas ähnliches.

    • +1 für die Empfehlung für Zeile-für-Zeile statt Spalte-für-Spalte
  5. 0

    Verwenden Sie den Rückgabetyp object, dann sind Sie in der Lage zu bekommen zurück geben. Sie haben, um die Rückkehr Art äther durch Reflexion oder eine andere Methode.

    prüfen:

    void Main()
    {
        object aa = VariableReturnExampleMethod(3);
        Console.WriteLine(aa.ToString());
    }
    
    object VariableReturnExampleMethod(int a)
    {
        if (a == 1)
            return "Demo";
        else if (a == 2)
            return 2;
        else if (a == 3)
            return true;
        else
            return null;
    }

    Bearbeiten:
    Ich bin in der Gunst der stark typisierte Objekte und implementieren Sie können es leicht auf .net-Plattform.

    if(returnedValue !=null)
    {
    
    string currentDataType = returnedValue.GetType().Name;
    object valueObj = GetValueByValidating(currentDataType, stringValue);
    }
    
    
     public object GetValueByValidating(string strCurrentDatatype, object valueObj)
            {
                if (valueObj != "")
                {
                    if (strCurrentDatatype.ToLower().Contains("int"))
                    {
                        valueObj = Convert.ToInt32(valueObj);
                    }
                    else if (strCurrentDatatype.ToLower().Contains("decimal"))
                    {
                        valueObj = Convert.ToDecimal(valueObj);
                    }
                    else if (strCurrentDatatype.ToLower().Contains("double") || strCurrentDatatype.ToLower().Contains("real"))
                    {
                        valueObj = Convert.ToDouble(valueObj);
                    }
                    else if (strCurrentDatatype.ToLower().Contains("string"))
                    {
                        valueObj = Convert.ToString(valueObj);
                    }
                    else
                    {
                        valueObj = valueObj.ToString();
                    }
                }
                else
                {
                    valueObj = null;
                }
                return valueObj;
            }
    • Er explizit nach einer Lösung gefragt, die nicht casting
  6. 0

    Ich freue mich auf Ihre Fragen und eine ist besser als der zweite, aber beim letzten muss ich nach dem umschreiben des um besser zu verstehen, die Lösung. Und diese Lösung skip () lange if -, else-Stapel und ersetzt Sie durch eine foreach-on-Typen enum, wo können wir die Durchführung aller Arten, was wir brauchen. Ich mehr wie mit dynamischen, aber diese ist nutzbar auch.

    Main-Funktion GetValueByValidating zurückgegebene Wert, wenn der Typ ist definiert und möglich, in anderen Fällen false zurück
    Schauen niranjan-kala dies ist Ihre wichtigste Funktion nach umschreiben.

    
    
                ///
            ///Enum of wanted types
            ///
            public enum Types
            {
                [ExtendetFlags("int")]
                INT,
                [ExtendetFlags("decimal")]
                DECIMAL,
                [ExtendetFlags("double")]
                DOUBLE,
                [ExtendetFlags("real")]
                REAL,
                [ExtendetFlags("string")]
                STRING,
                [ExtendetFlags("object")]
                OBJECT,
                [ExtendetFlags("null")]
                NULLABLE
            }
            ///
            ///Cycle by types when in enum exist string reference on type (helper)
            ///
            ///
            ///
            public static Types GetCurrentType(string container)
            {
                foreach (Types t in Enum.GetValues(typeof(Types)))
                {
                    if (container.Contains(t.GetFlagValue()))
                    {
                        return t;
                    }
                }
                return Types.NULLABLE;
            }
            ///
            ///Return object converted to type
            ///
            ///
            ///
            ///
            public static object GetValueByValidating(string strCurrentDatatype, object valueObj)
            {
                var _value = valueObj != null ? valueObj : null;
                try
                {
                    Types _current = _value != null ? GetCurrentType(strCurrentDatatype.ToLower()) : Types.NULLABLE;
    
                    switch (_current)
                    {
                        case Types.INT:
                            valueObj = Convert.ToInt32(valueObj);
                            break;
                        case Types.DECIMAL:
                            valueObj = Convert.ToDecimal(valueObj);
                            break;
                        case Types.DOUBLE:
                            valueObj = Convert.ToDouble(valueObj);
                            break;
                        case Types.REAL:
                            valueObj = Convert.ToDouble(valueObj);
                            break;
                        case Types.STRING:
                            valueObj = Convert.ToString(valueObj);
                            break;
                        case Types.OBJECT:
                            break;
                        case Types.NULLABLE:
                            throw new InvalidCastException("Type not handled before selecting, function crashed by retype var.");
                    }
                } catch (InvalidCastException ex)
                {
                    Log.WriteException(ex);
                    valueObj = false;
                }
    
                return valueObj;
            }
    
    

Kostenlose Online-Tests