Truyền một hệ thống tức thời. Nhập vào dưới dạng tham số loại cho lớp chung

Tiêu đề là loại tối nghĩa. Những gì tôi muốn biết là nếu điều này là có thể:

string typeName = <read type name from somwhere>;
Type myType = Type.GetType(typeName);

MyGenericClass<myType> myGenericClass = new MyGenericClass<myType>();

Rõ ràng, MyGenericClass được mô tả là:

public class MyGenericClass<T>

Ngay bây giờ, trình biên dịch phàn nàn rằng 'Không thể tìm thấy loại hoặc không gian tên' myType '. "Phải có một cách để làm điều này.

Bạn không thể làm điều này mà không có sự phản ánh. Tuy nhiên, bạn có thể làm điều đó với sự phản ánh. Đây là một ví dụ hoàn chỉnh:

using System;
using System.Reflection;

public class Generic<T>
{
    public Generic()
    {
        Console.WriteLine("T={0}", typeof(T));
    }
}

class Test
{
    static void Main()
    {
        string typeName = "System.String";
        Type typeArgument = Type.GetType(typeName);

        Type genericClass = typeof(Generic<>);
        // MakeGenericType is badly named
        Type constructedClass = genericClass.MakeGenericType(typeArgument);

        object created = Activator.CreateInstance(constructedClass);
    }
}

Lưu ý: nếu lớp chung của bạn chấp nhận nhiều loại, bạn phải bao gồm dấu phẩy khi bạn bỏ qua tên loại, ví dụ:

Type genericClass = typeof(IReadOnlyDictionary<,>);
Type constructedClass = genericClass.MakeGenericType(typeArgument1, typeArgument2);

Thật không may là không có. Các đối số chung phải được phân giải tại thời gian Biên dịch là 1) loại hợp lệ hoặc 2) tham số chung khác. Không có cách nào để tạo các thể hiện chung dựa trên các giá trị thời gian chạy mà không cần đến việc sử dụng sự phản chiếu.

Một số cách bổ sung để chạy với mã kéo. Giả sử bạn có một lớp tương tự

public class Encoder() {
public void Markdown(IEnumerable<FooContent> contents) { do magic }
public void Markdown(IEnumerable<BarContent> contents) { do magic2 }
}

Giả sử trong thời gian chạy bạn có FooContent

Nếu bạn có thể liên kết vào thời gian biên dịch, bạn sẽ muốn

var fooContents = new List<FooContent>(fooContent)
new Encoder().Markdown(fooContents)

Tuy nhiên bạn không thể làm điều này trong thời gian chạy. Để làm điều này trong thời gian chạy, bạn sẽ làm theo dòng:

var listType = typeof(List<>).MakeGenericType(myType);
var dynamicList = Activator.CreateInstance(listType);
((IList)dynamicList).Add(fooContent);

Để tự động gọi Markdown(IEnumerable<FooContent> contents)

new Encoder().Markdown( (dynamic) dynamicList)

Lưu ý việc sử dụng dynamictrong cuộc gọi phương thức. Trong thời gian chạy dynamicListsẽ List<FooContent>(ngoài ra cũng vậy IEnumerable<FooContent>) vì ngay cả việc sử dụng động vẫn bắt nguồn từ một ngôn ngữ được gõ mạnh, chất kết dính thời gian chạy sẽ chọn Markdownphương thức thích hợp . Nếu không có loại khớp chính xác, nó sẽ tìm một phương thức tham số đối tượng và nếu không khớp với ngoại lệ liên kết thời gian chạy sẽ được đưa ra cảnh báo rằng không có phương thức nào khớp.

Điểm thu hút rõ ràng của phương pháp này là sự mất mát lớn về an toàn kiểu tại thời điểm biên dịch. Tuy nhiên, mã dọc theo các dòng này sẽ cho phép bạn hoạt động theo một nghĩa rất năng động rằng tại thời gian chạy vẫn được gõ đầy đủ như bạn mong đợi.

Yêu cầu của tôi hơi khác một chút, nhưng hy vọng sẽ giúp được ai đó. Tôi cần phải đọc kiểu từ một cấu hình và khởi tạo kiểu chung một cách linh hoạt.

namespace GenericTest
{
    public class Item
    {
    }
}

namespace GenericTest
{
    public class GenericClass<T>
    {
    }
}

Cuối cùng, đây là cách bạn gọi nó. Xác định loại với một backtick .

var t = Type.GetType("GenericTest.GenericClass`1[[GenericTest.Item, GenericTest]], GenericTest");
var a = Activator.CreateInstance(t);

Nếu bạn biết loại nào sẽ được thông qua, bạn có thể làm điều này mà không cần phản ánh. Một tuyên bố chuyển đổi sẽ làm việc. Rõ ràng, điều này sẽ chỉ hoạt động trong một số trường hợp hạn chế, nhưng nó sẽ nhanh hơn nhiều so với phản xạ.

public class Type1 { }

public class Type2 { }

public class Generic<T> { }

public class Program
{
    public static void Main()
    {
        var typeName = nameof(Type1);

        switch (typeName)
        {
            case nameof(Type1):
                var type1 = new Generic<Type1>();
                // do something
                break;
            case nameof(Type2):
                var type2 = new Generic<Type2>();
                // do something
                break;
        }
    }
}

Trong đoạn trích này tôi muốn chỉ ra cách tạo và sử dụng danh sách được tạo động. Ví dụ: tôi đang thêm vào danh sách động ở đây.

void AddValue<T>(object targetList, T valueToAdd)
{
    var addMethod = targetList.GetType().GetMethod("Add");
    addMethod.Invoke(targetList, new[] { valueToAdd } as object[]);
}

var listType = typeof(List<>).MakeGenericType(new[] { dynamicType }); // dynamicType is the type you want
var list = Activator.CreateInstance(listType);

AddValue(list, 5);

Tương tự, bạn có thể gọi bất kỳ phương thức nào khác trong danh sách.