如何创建通用类型类的新实例

Question

Questions:

1. How do I create, set, and return and instantiated object of type "T"?
2. How would I access the subclass type (Tag : DataBASE) in a static function?

I'm trying to create a generic "GetAsClass" function which would return an initialized instance of the subclass. I can't figure out how to create a new instance of the class I want to return and return the subclass type.

Say I have two classes:

1. Tag
2. User

I want to create a single function in the base class which will get whatever type it is. On another note, I'd like to make it static as well (but then I don't have access to "this" and I'm not sure how to get the subclass type.

    private async Task<T> GetAsClass<T>(string objectId) {

        Type classType = this.GetType();
        string className = classType.Name; 

        // This needs to be of type "T" (Tag myTag = new Tag();) How would I accomplish something like this?
        object toReturnObject = new object();
        ParseObject myParseObject = ParseObject.GetAsParseObject(objectId);

        foreach (PropertyInfo field in classType.GetRuntimeProperties()) {
            if (field.CanRead) {
                string propertyName = StringHelper.ToLowerCamelCase(field.Name);
                if (field.PropertyType == typeof(string)) {
                    string propertyValue = myParseObject.Get<string>(propertyName);
                    field.SetValue(toReturnObject , propertyValue);
                }
                if (field.PropertyType == typeof(int)) {
                    int propertyValue = myParseObject.Get<int>(propertyName);
                    field.SetValue(toReturnObject, propertyValue);
                }
            }
        }

        return toReturnObject;
    }

Higher Resolution: http://snag.gy/FbCfu.jpg

Answer 1

You may find this page on generic type constraints to be helpful. Basically, you would change the signature of your class/method to be:

private async Task<T> GetAsClass<T>(string objectId)
    where T: new()
{
    ...
}

And it will accept types of T only if it provides a default constructor with no arguments. Once that condition is guaranteed, then your class can invoke new T()