为方法声明设置多个返回值

本文关键字：返回值 设置 方法 声明 | 更新日期: 2023-09-27 18:03:17

我有一个函数如下:

  public var UpdateMapFetcher(int stationID, int typeID)

我需要这个函数返回string或int。

我的返回值设置如下

 if (finaloutput == "System.String")
        {
            // param1[i] = Convert.ChangeType(typeID_New.ToString(), typeof(string));
            returnvalue = returnvalue.ToString();
            return returnvalue;
        }
        else if (finaloutput == "System.Int32")
        {
            int a=0;
            a = Convert.ToInt32(returnvalue);
            return a;
        }

如何在动态环境中使用一种数据类型作为返回值。

为方法声明设置多个返回值

我的直觉告诉我，您正在尝试将字符串值转换为某种类型。在这种情况下，您可以使用:

public T UpdateMapFetcher<T>(int stationID)
{
    //var someValue = "23";
    return (T)Convert.ChangeType(someValue, typeof(T));
}
//then
var typed = UpdateMapFetcher<int>(6);

如果你不知道T，你可以使用mapping (0-int, 1-string，等等):

public object UpdateMapFetcher(int stationID, int type)
{
    var typeMap = new []{ typeof(int), typeof(string)};
    //var someValue = "23";
    return Convert.ChangeType(someValue, typeMap[type]);
}
//then
var untyped = UpdateMapFetcher(6, 0/*0 is int*/);
if (untyped.GetType() == typeof(int))
{ /*is int*/
}
另一个解决方案是使用隐式转换: 
public class StringOrInt
{
    private object value;
    public ValueType Type { get; set; }
    public static implicit operator StringOrInt(string value)
    {
        return new StringOrInt()
        {
            value = value,
            Type = ValueType.String
        };
    }
    public static implicit operator StringOrInt(int value)
    {
        return new StringOrInt()
        {
            value = value,
            Type = ValueType.Int
        };
    }
    public static implicit operator int(StringOrInt obj)
    {
        return (int)obj.value;
    }
    public static implicit operator string(StringOrInt obj)
    {
        return (string)obj.value;
    } 
}
public enum ValueType
{
    String,
    Int
}

然后(简化):

public static StringOrInt UpdateMapFetcher(int stationID, int typeID)
{
    if (typeID == 0)
        return "Text";
    return 23;
}
private static void Main(string[] args)
{
    var result = UpdateMapFetcher(1, 1);
    if (result.Type == ValueType.String) { }//can check before
    int integer = result;//compiles, valid
    string text = result;//compiles, fail at runtime, invalid cast      
}

可以返回一个对象。随后必须检查消费方法中的类型。我想这在您的使用案例中不会有问题。

你的方法签名因此是:

public object UpdateMapFetcher(int stationID, int typeID)

您还可以选择使用out关键字，它允许您接受这两个into变量，并在调用函数后进行检查。

public void UpdateMapFetcher(int stationID, int typeID, out int intValue, out string strValue)
// or int return val and out string value
public int UpdateMapFetcher(int stationID, int typeID, out string strValue)

用法如下:

int intVal;
string strVal;
UpdateMapFetcher(stationID, typeID, out intVal, out strVal);
if (strVal != null) 
{ 
    doSomethingWithString(strVal); 
}
else
{
    doSomethingWithInt(intVal);
}

坦白地说，我只会返回一个Tuple，其中string是非空的表示要使用的字符串值，null作为int return

的指示符
public Tuple<string, int> UpdateMapFetcher(int stationID, int typeID) {
    if (finaloutput == "System.String")
    {
        // param1[i] = Convert.ChangeType(typeID_New.ToString(), typeof(string));
        returnvalue = returnvalue.ToString();
        return new Tuple<string, int>(returnvalue, 0);
    }
    else if (finaloutput == "System.Int32")
    {
        int a=0;
        a = Convert.ToInt32(returnvalue);
        return new Tuple<string, int>(null, a);
    }
}

消费者端

var rc = UpdateMapFetcher( .... );
if (rc.Item1 != null) {
    // code to use string value
} else {
   // code to use int value
}

我会选择返回新的class的object，它可能看起来像这样:

class Result {
    public string StringValue { get; }
    public string Int32Value { get; }
    public bool IsString { get; }
    public bool IsInt32 { get; }
    public Result(string value) {
        StringValue = value;
        IsString = true;
    }
    public Result(int value) {
        Int32Value = value;
        IsInt32 = true;
    }
}

这样你就可以通过使用Isxxx属性来检查哪个Type是它。您还可以通过值get的验证来增强这一点。例如，对于string，它可能看起来像这样:

public string StringValue {
    get {
        if (IsString)
            return m_stringValue;
        throw new InvalidOperationException("Value is not a string.");
    }
}

您不可能完全做到，但是有几种方法可以或多或少地做到您想要的。不过你最好稍微改变一下设计。

两个想法:

  • 改变你的代码使用两个不同的方法，并调用他们每一个需要代替
  • . .或者返回一个对象，你可以随心所欲地强制转换。
  • . .或者，使用TypeDescriptor的泛型方法，如下所示:

注意，这里我们首先将值转换为string，即使它是int型，因为我们可以使用通用方法ConvertFromString()将其转换为T的任何类型。

public T UpdateMapFetcher<T>(int stationID, int typeID) {
    // To allow parsing to the generic type T:
    var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
    if(converter != null)
    {
        return (T)converter.ConvertFromString(returnvalue.ToString());
    }    
    else
    {
        return default(T);
    }
}

用法:

var result = MyExtensions.UpdateMapFetcher<string>(1, 2);

或:

var result = MyExtensions.UpdateMapFetcher<int>(1, 2);

您可以返回Object并强制转换为您想要的类型

public Object UpdateMapFetcher(int stationID, int typeID)
if (finaloutput == "System.String")
        {
            // param1[i] = Convert.ChangeType(typeID_New.ToString(), typeof(string));
            returnvalue = returnvalue.ToString();
            return returnvalue;
        }
        else if (finaloutput == "System.Int32")
        {
            int a=0;
            a = Convert.ToInt32(returnvalue);
            return a;
        }

可以包含一种类型或另一种类型的类型通常被称为(毫不奇怪)Either。它是和类型的特殊情况，基本上是判别联合， 标记联合，或不相交联合，只有两种情况(而不是任意数字)。

不幸的是，在标准库中没有Either类型的实现，但是在Google, GitHub和其他地方有很多实现，并且从Haskell或Scala移植一个现有的实现并不难。

它看起来有点像这样(原谅我的代码，我实际上不太了解c#):

using System;
abstract class Either<A, B>
{
    public abstract bool IsLeft { get; }
    public abstract bool IsRight { get; }
    public abstract A Left { get; }
    public abstract B Right { get; }
    public abstract A LeftOrDefault { get; }
    public abstract B RightOrDefault { get; }
    public abstract void ForEach(Action<A> action);
    public abstract void ForEach(Action<B> action);
    public abstract void ForEach(Action<A> leftAction, Action<B> rightAction);
    private sealed class L : Either<A, B>
    {
        private A Value { get; }
        public override bool IsLeft => true;
        public override bool IsRight => false;
        public override A Left => Value;
        public override B Right { get { throw new InvalidOperationException(); } }
        public override A LeftOrDefault => Value;
        public override B RightOrDefault => default(B);
        public override void ForEach(Action<A> action) => action(Value);
        public override void ForEach(Action<B> action) {}
        public override void ForEach(Action<A> leftAction, Action<B> rightAction) => leftAction(Value);
        internal L(A value) { Value = value; }
    }
    private sealed class R : Either<A, B>
    {
        private B Value { get; }
        public override bool IsLeft => false;
        public override bool IsRight => true;
        public override A Left { get { throw new InvalidOperationException(); } }
        public override B Right => Value;
        public override A LeftOrDefault => default(A);
        public override B RightOrDefault => Value;
        public override void ForEach(Action<A> action) {}
        public override void ForEach(Action<B> action) => action(Value);
        public override void ForEach(Action<A> leftAction, Action<B> rightAction) => rightAction(Value);
        internal R(B value) { Value = value; }
    }
    public static Either<A, B> MakeLeft(A value) => new L(value);
    public static Either<A, B> MakeRight(B value) => new R(value);
}

你可以这样使用:

static class Program
{
    public static void Main()
    {
        var input = Console.ReadLine();
        int intResult;
        var result = int.TryParse(input, out intResult) ? Either<int, string>.MakeLeft(intResult) : Either<int, string>.MakeRight(input);
        result.ForEach(r => Console.WriteLine("You passed me the integer one less than " + ++r), r => Console.WriteLine(r));
    }
}
相关文章：