相关疑难解决方法(0)

当在编译时未知类型参数但是在运行时动态获取时,调用泛型方法的最佳方法是什么？

考虑以下示例代码 - 在Example()方法内部,GenericMethod<T>()使用Type存储在myType变量中调用的最简洁方法是什么？

public class Sample
{
    public void Example(string typeName)
    {
        Type myType = FindType(typeName);

        // What goes here to call GenericMethod<T>()?
        GenericMethod<myType>(); // This doesn't work

        // What changes to call StaticMethod<T>()?
        Sample.StaticMethod<myType>(); // This also doesn't work
    }

    public void GenericMethod<T>()
    {
        // ...
    }

    public static void StaticMethod<T>()
    {
        //...
    }
}

是否可以创建一个方法,将任何方法(不管它的参数)作为参数？该方法还有一个params参数,然后获取参数方法的所有参数.

基本上我想要的是这样的:

public void CallTheMethod(Action<int> theMethod, params object[] parameters)

但是对于任何方法,不仅仅是采用int的方法.

这样的事情可能吗？

谢谢

我想创建一个强类型列表并在运行时决定类型.这是我的代码.我认为它应该工作,但它没有:)

        Type elementType = Type.GetType(parts[0].Trim(),false,true);
        var elementsBeingSet = new List<elementType>();

你有什么想法如何创建一个强类型列表,其类型我将在运行时决定？

重复:这是其他版本:

• 是否无法动态使用泛型？
• 动态声明泛型类型实例
• 使用仅在执行时知道的类型参数调用泛型方法

我有这个方法:

public List<T> SomeMethod<T>( params ) where T : new()

所以SomeMethod如果我知道类型,我想称之为好的:

SomeMethod<Class1>();

但如果我只是Class1在运行时我无法调用它？

那么如何SomeMethod使用未知的T型调用？我用反射得到了Type.

我有类型的类型,但SomeMethod<Type | GetType()>不起作用.

更新7. May:

以下是我想要实现的示例代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace ConsoleApplication63
{
    public class DummyClass
    {
    }

    public class Class1
    {
        public string Name;
    }

    class AssemblyTypesReflection
    {
        static void Main(string[] args)
        {
            object obj = new Class1() { Name = "John" } ;

            Assembly assembly = Assembly.GetExecutingAssembly();
            var AsmClass1 = …

我正在从现有代码构建一个Universal类库,并且我得到了一些编译器警告,我在其生命中无法弄清楚该怎么做.

我有这样的代码:

void SomeMethod(Object data)
{
  var size = Marshal.SizeOf(data);
  ...
}

代码构建,但在Universal项目(我猜,.NET 4.5.1及更高版本的项目)中,我得到以下编译器警告:

警告CS0618:'System.Runtime.InteropServices.Marshal.SizeOf(object)'已过时:'SizeOf(Object)在将来的版本中可能不可用.而是使用SizeOf <T>().

但是如何Marshal.SizeOf(Object)使用通用无参数方法在上述情况下创建替换Marshal.SizeOf<T>()？从理论上讲,我可能不知道是什么类型data的？

是因为使用Marshal.SizeOf(Object)被认为是错误的做法,它被归因Obsolete？带回家的消息应该是"完全重构代码"？

如何动态加载"MyContent"类？我有1,1 interface<T>个抽象泛型class<T>和1个类.检查我的代码:

public interface IMyObjectInterface{
}
public abstract MyAbstractObject : IMyObjectInterface{
}
public class MyObject : MyAbstractObject{
}

public interface IMyContentInterface<T>  where T : MyAbstractObject
{
  void MyMethod();
}
public abstract MyAbstractContent<T>, IMyContentInterface<T>  where T : MyAbstractObject
{
  public abstract void MyMethod();
}
public public class MyContent : MyAbstractContent<MyObject>
{
  public override void MyMethod() { //do something }
}

我正在尝试,但显然它不起作用:

IMyObjectInterface obj = (IMyObjectInterface)Assembly.Load("MyAssembly").CreateInstance("MyObject");
IMyContentInterface<obj> content = (IMyContentInterface<obj>)Assembly.Load("MyAssembly").CreateInstance("MyContent");
content.MyMethod();
//assembly and type names are correct

如果我换IMyContentInterface<obj> …

我有一大堆自动生成的对象.尽管它们都是不同的非相关类,但所有对象都共享一些基本属性(名称,ID等).我不控制这些对象的生成,所以不幸的是我无法采用实现接口的理想方法.我想创建一个方法,在其中我传递这些对象中的任意一个并使用这些公共属性执行某些操作.

一般的想法是这样的:

someObj a = new someObj();
a.name = "sara";
diffObj b = new diffObj();
b.name = "joe";
string phrase = string.Format("I am with {0} and {1}", 
    getName(a), getName(b));

private string getName(object anyObjWithName)
{
    return anyObjWithName.name;
}

虽然自然这不起作用.

我认为泛型方法可能会有答案,但我能看到用当前类型调用它的唯一方法是使用genericMethod.Invoke,这仍然带有同样的问题,即无法解析方法中传递的对象的属性.这与Calling泛型方法不同,它只有在执行时才知道的类型参数或如何用给定的Type对象调用泛型方法？其中只有类型的类型或属性在方法中使用,而不是对象的属性.

我知道这会(非常)容易出错,但我可以保证遇到的所有对象都会被操纵共同的属性.

我有一个转换器,允许我在SelectedItems和Generic之间进行转换 List<MyType>

public class SelectedTiposDocsToList : BaseConverter, IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        var Selecteditems = value as IList;
        List<MyType> MyTypeList = Selecteditems.Cast<MyType>().ToList();
        return MyTypeList;
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        throw new NotImplementedException();
    }
} 

现在这对我来说是一个常见的任务,并希望扩展这个类以允许泛型类型,这可能是这样的吗？

public class SelectedTiposDocsToList : BaseConverter, IValueConverter
{
    public object Convert<T>(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        var Selecteditems = value as IList;
        List<T> MyTypeList = Selecteditems.Cast<T>().ToList();
        return MyTypeList; …

我有一堂课，看起来像下面这样：

class FooClassAnalyser<T extends Foo> extends ClassAnalyser<T>

（哪里ClassAnalyser是许多具体实现的抽象基类；并且FooClassAnalyser是专门针对T扩展情况的具体实现Foo）。它具有一个如下所示的构造函数：

FooClassAnalyser(Class<T> classToAnalyse)

在另一个类中，我有一个用于ClassAnalyser的静态工厂方法，该方法根据类型调用一个适当的构造函数classToAnalyse：

static <U> ClassAnalyser<U> constructClassAnalyser(Class<U> classToAnalyse)

我想要的功能是检查U instanceof Foo，然后构造一个FooClassAnalyser，如果是，则将其返回。

但是，我找不到在Java的类型系统中适合此方法。类型擦除意味着我们不能U直接做任何聪明的事情。但是，我们classToAnalyse作为参数传入的事实使得可以U instanceof Foo通过使用反射来测试是否通过测试：

if (Foo.class.isAssignableFrom(classToAnalyse))

我的问题是，与instanceofJava 不同，这种“通过反射的实例”对Java的类型系统不可见。特别是，将classToAnalyse参数直接传递给FooClassAnalyser的构造函数会失败，并导致类型不匹配，因为Java不知道这classToAnalyse实际上是一个Class<U extends Foo>。

到目前为止，我已经找到了最好的解决方案是使用未经检查的铸造，使classToAnalyse一个Class<? extends Foo>（它是实际检查，但Java的不知道它的选中）。至少可以将其作为参数传递给new FooClassAnalyser，并获得FooClassAnalyser<?>返回的对象。但是，问题在于，它不会再转换为ClassAnalyser<U>，因为Java无法识别强制classToAnalyse转换具有不同的泛型绑定，但这并不会改变Class对象仍然是同一对象的事实（因此，仍然是 …

我有这样的功能

public static void serialize<T>(T serializeObject){
    //this is the trouble
    SerializableEntity<T> entity = new SerializableEntity<T>(serializeObject);
}

如何在泛型中使用泛型？怎么做到这一点？

UPDATE

这里编译错误: