C#中方法的变量返回类型

Question

我想给一个方法一个参数，我希望我的方法通过查看参数来返回数据。数据可以是布尔、字符串、整数等类型。如何从方法中返回变量类型？我不想返回一个对象类型，然后将其转换为另一种类型。例如：

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

我想要这样做的原因是我有一种方法可以从数据库中读取一行的选定列。列的类型不一样，但我必须返回每一列的信息。

Answer 1

如何从方法中返回变量类型？我不想返回一个对象类型，然后将其转换为另一种类型。

这基本上就是你做必须做的。或者，如果您使用 C# 4，则可以将返回类型设为 dynamic，这将允许隐式转换：

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);

从根本上说，您指定类型以让编译器 知道会发生什么。如果类型只在 执行 时知道，那怎么能工作呢？ dynamic 版本起作用的原因是它基本上告诉编译器将其正常工作推迟到直到执行时间 - 所以你失去了正常的安全性，这会让第二个示例在编译时失败。

Answer 2

如果您的目标是.Net 4.0，请使用dynamic 关键字代替BlahBlah，但如果您的目标较小，那么object 是您最安全的选择，因为它是您能想到的所有其他类的基类。

Answer 3

听起来这可能是generics 的一个好案例。如果您在调用它时知道期望的数据类型，则可以调用该函数的特定通用版本。

Answer 4

考虑使用类似 Dapper-dot-net（由 Marc Gravell 和 Sam Saffron 在我们自己的 Stack Overflow 上编写）之类的东西从数据库中提取内容。它为您处理数据库到对象的映射。

此外，如果您不想使用工具，并且从数据库中提取数据，并且您在编译时就知道各个列的数据类型（就像听起来一样），那么您可能应该是逐行而不是逐列工作。

//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);
}

注意：您可以在此处使用对象初始化器语法和 linq，但这是我能想到的最基本的演示方法，而无需使用大量额外的东西。

另外请注意，这里我假设您实际上不想返回“Demo”、2 和 true，而是使用该行的值。这只是意味着您将硬编码值更改为：row.GetStringType(stringColumnIdx) 或类似的东西。

Answer 5

使用返回类型为object，那么你可以得到任何返回类型。您必须通过反射或其他方法处理返回类型ether。

检查一下：

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;
}

编辑： 我赞成强类型对象，你可以在 .net 平台上轻松实现它。

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;
        }

Answer 6

我看看你的问题，一个比第二个好，但最后我必须重写以更好地理解解决方案。这个解决方案跳过了很长的 if else stack 并在 Types 枚举上用 foreach 替换它，在那里我们可以实现我们需要的所有类型。我更喜欢使用动态，但这也可以使用。

主函数GetValueByValidating如果类型已定义且可能返回值，其他情况返回false 看niranjan-kala这是你重写后的主要功能。

            /// 
        /// 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;
        }