C#是否可以将类型传递给方法并让该方法返回该类型的对象？

这似乎是可能的

protected SameObjectTypeAsInputParameterObjectType GetAValue(someObject,TypeOrReturnObjectYouWant){

//check to see if someObject is null, if not, cast it and send the cast back

}

---

这似乎会做得更好

您可以做的是：

var requestedObject = someObject as TheTypeYouWant;

当您声明类似的内容时，将不会得到null引用异常。然后你可以做一个简单的

if(requestedObject != null){
    ...
}

使用泛型：

T foobar<T>() where T : new()
{
    return new T();
}
void somefunc()
{
    Guid g = foobar<Guid>();
}

protected T GetAValue<T>(object someObject)
{
    if (someObject is T)
    {
        return (T)someObject;
    }
    else
    {
        // We cannot return null as T may not be nullable
        // see http://stackoverflow.com/questions/302096/how-can-i-return-null-from-a-generic-method-in-c
        return default(T); 
    }
}

T foobar（），其中T:new（）
{
返回新的T（）；
}
void somefunc（）
{
Guid g=foobar（）；
}

您可以这样定义方法：

protected TReturnType GetAValue<TReturnType>(Object someObject) where TReturnType : class
{
 if(someObject is TReturnType) return (TReturnType) someObject;
 return null;
}

受保护的TReturnType GetAValue（Object someObject），其中TReturnType:class
{
如果（someObject是TReturnType）返回（TReturnType）someObject；
返回null；
}

---

或者，如果您不能保证TReturnType是引用类型，您可以取消泛型约束（TReturnType:class）并返回默认值（TReturnType），而不是null-这将返回TReturnType的默认类型，对于int，它将是0。

如果您在编译时（编写代码时）知道该类型您可以使用泛型

---

如果您只知道运行时的类型（通过type），则可以使用该类。

这种转换可以使用

as

requestedObject as RequestedType

---

将此表达式包装在方法中并不能真正买到任何东西

在给定的示例中，只需执行以下操作可能会更好：

MyClass val = myObject as MyClass;

然而，要回答您的问题-是的，答案是使用泛型：

T foobar<T>() where T : new()
{
    return new T();
}
void somefunc()
{
    Guid g = foobar<Guid>();
}

protected T GetAValue<T>(object someObject)
{
    if (someObject is T)
    {
        return (T)someObject;
    }
    else
    {
        // We cannot return null as T may not be nullable
        // see http://stackoverflow.com/questions/302096/how-can-i-return-null-from-a-generic-method-in-c
        return default(T); 
    }
}

---

有关更多信息，请查看

我认为您实际上可能正在寻找Convert.ChangeType机制

private static object ChangeTypeTo<T>(this object value)
{
    if (value == null)
        return null;

    Type underlyingType = typeof (T);
    if (underlyingType == null)
        throw new ArgumentNullException("value");

    if (underlyingType.IsGenericType && 
           underlyingType.GetGenericTypeDefinition().Equals(typeof (Nullable<>)))
    {
        var converter = new NullableConverter(underlyingType);
        underlyingType = converter.UnderlyingType;
    }

    // Guid convert
    if (underlyingType == typeof (Guid))
    {
        return new Guid(value.ToString());
    }

    // Check for straight conversion or value.ToString conversion
    var objType = value.GetType();

    // If this is false, lets hope value.ToString can convert otherwise exception
    bool objTypeAssignable2typeT = underlyingType.IsAssignableFrom(objType);

    // Do conversion
    return objTypeAssignable2typeT ? Convert.ChangeType(value, underlyingType)
            : Convert.ChangeType(value.ToString(), underlyingType);
}

私有静态对象ChangeTypeTo（此对象值）
{
如果（值==null）
返回null；
类型UnderlineType=类型（T）；
if（underlyngType==null）
抛出新的ArgumentNullException（“值”）；
if（underyingtype.IsGenericType&&
underlineType.GetGenericTypeDefinition（）.Equals（typeof（Nullable）））
{
var转换器=新的NullableConverter（UnderlineType）；
underlyingType=转换器。underlyingType；
}
//Guid转换
if（underlineType==typeof（Guid））
{
返回新的Guid（value.ToString（））；
}
//检查直线转换或value.ToString转换
var objType=value.GetType（）；
//如果为false，则希望value.ToString可以转换为其他异常
bool objTypeAssignable2typeT=underyingtype.IsAssignableFrom（objType）；
//转换
返回objTypeAssignable2typeT？Convert.ChangeType（值，underyingType）
：Convert.ChangeType（value.ToString（），underyingType）；
}

foobar（）：如果不使用new（）

，您将无法这样做。此外，这似乎符合标题中指定的标准，但不符合实际问题中的标准。OP希望将输入对象强制转换为新类型。您需要在此处返回默认值（T），因为null不适用于值类型-或者在方法=>上放置一个泛型约束，其中T:CLASS您可以只返回

默认值

，而不返回

（T）

部分，它会自动返回方法返回类型的默认值。