C＃，使用委托函数更新列表作为过滤器

Question

当条件（pred）对其某个类成员（值）成立时，我想更新对象列表（mycapsule，有许多其他成员）。每当我改变一件事情失败时，我都是C＃的新手，真的很困惑。 有人可以解决我的代码： 在最佳状态我只得到得到这个错误，但我觉得很多事情都是在我的代码

The type or namespace name `T' could not be found. Are you missing a using directive or an assembly reference? 

这里缺少的是我的代码

using System; 
using System.Collections.Generic ; 
namespace test 
{ 
    class MainClass 
    { 
     public static List< mycapsule<int,double> > sample= new List< mycapsule<int,double>>(); 
     public static void Main (string[] args) 
     { 

      sample.Add(new mycapsule<int,double> {id=1 , value= 1.2}); 
      update(pred, 12.3); 
     } 

     public static bool pred(double x) 
     { 
      if (x==2.5) return true; 
      return false; 
     } 
     public class mycapsule<KT, T> 
     { 
      public KT id {get ; set; } 
      public T value { get ; set; } 
      public int p; // and more 

     }  

     public bool update(Func<T, bool> predicate, T i) 
     { 
      foreach (var x in sample.FindAll(item => predicate(JustValue(item)))) 
      { 
       x.value = i ; 
      } 
      return true ; 
     } 



     public T JustValue(mycapsule<int,T> i) 
     { 
      return i.value; 
     } 

    } 
} 

Answer 1

这恐怕是行不通的，由于类型安全的原因。我纠正了代码，并尽可能得到这个：

public static List<mycapsule<int, double>> sample = new List<mycapsule<int, double>>(); 
public static void Main(string[] args) 
{ 
    sample.Add(new mycapsule<int, double> { id = 1, value = 1.2 }); 
    update(pred, 12.3); 
} 

public static bool pred(double x) 
{ 
    if (x == 2.5) return true; 
    return false; 
} 

public class mycapsule<KT, T> 
{ 
    public KT id { get; set; } 
    public T value { get; set; } 
    public int p; // and more 
} 

public static bool update<T>(Func<T, bool> predicate, T i) 
{ 
    List<mycapsule<int, double>> list = sample.FindAll(item => predicate(JustValue(item))); 
    foreach (var x in list) 
    { 
     x.value = i; 
    } 
    return true; 
} 

public static T JustValue<T>(mycapsule<int, T> i) 
{ 
    return i.value; 
} 

的错误是：

predicate(JustValue(item)) => Argument 1: cannot implicitly convert from double to T 

这源于一个事实，即你正在试图强行调用您指定的方法采用已知值为double的通用类型T（Func<T, bool>）。虽然我们知道T将是双从呼叫update(pred, 12.3);，没有什么能阻止我从传递一个谓词，采用不兼容的类型例如为：

public static bool pred(string x) 
{ 
    return false; 
} 

和

update(pred, "asdf"); 

这显然是不一致的。编译器只是试图防止你意外地在脚中射击自己。

为了解决这个问题，你可以明确地集合传递到更新method，从而确保该类型是一致的：

public static List<mycapsule<int, double>> sample = new List<mycapsule<int, double>>(); 
public static void Main(string[] args) 
{ 
    sample.Add(new mycapsule<int, double> { id = 1, value = 1.2 }); 
    update(pred, 12.5, sample); 
} 

public static bool pred(double x) 
{ 
    if (x == 2.5) return true; 
    return false; 
} 

public class mycapsule<KT, T> 
{ 
    public KT id { get; set; } 
    public T value { get; set; } 
    public int p; // and more 
} 

public static bool update<T>(Func<T, bool> predicate, T i, List<mycapsule<int, T>> list) 
{ 
    foreach (var x in list.FindAll(item => predicate(JustValue(item)))) 
    { 
     x.value = i; 
    } 
    return true; 
} 

public static T JustValue<T>(mycapsule<int, T> i) 
{ 
    return i.value; 
} 

Answer 2

看看你的更新方法：

public bool update(Func<T, bool> predicate, T i) 
{ 
    foreach (var x in KeyRecord.FindAll(item => predicate(JustValue(item)))) 
    { 
     x.value = i ; 
    } 
    return true ; 
} 

你期望T在这里？该方法不是通用的（它不会被编写为update<T>），也不会在泛型类中声明。

这是可能你只是想：

public bool update<T>(Func<T, bool> predicate, T i) 

...但很难不知道什么KeyRecord.FindAll样子说。噢，你的JustValue也有同样的问题。

作为一个侧面问题，方法名称update和pred不遵循.NET命名约定，并且JustValue在描述性方面是一个糟糕的方法名称。 mycapsule也不遵循.NET命名约定。在可读性方面，这些东西真的是问题。

Answer 3

试试这个，对于泛型方法，你使用的方法定义是不正确的。
应该

//MethodName<T,U>(T para1, U para2) 

我修改了代码，包括反射，这应该工作。 请尝试并提供反馈。

using System; 
using System.Collections.Generic; 
using System.Reflection; 
namespace test 
{ 
    class MainClass 
    { 
     public static List<Mycapsule<int, double>> sample = new List<Mycapsule<int, double>>(); 

     public static void Main(string[] args) 
     { 

      sample.Add(new Mycapsule<int, double> { id = 1, value = 1.2 }); 
      update(pred, 12.3); 
     } 

     public static bool pred(double x) 
     { 
      if (x == 2.5) return true; 
      return false; 
     } 

     public static bool update<T>(Func<T, bool> predicate, T i) 
     { 
      var myCollection = sample.FindAll(p => pred(JustValue<double>(p))); 
      MainClass mainClass = new MainClass(); 
      foreach (var x in myCollection) 
      { 
       MethodInfo changeTypeMethod = typeof(MainClass).GetMethod("GetValue"); 
       object value = changeTypeMethod.Invoke(mainClass, new object[] { i, typeof(T) }); 
       PropertyInfo valueProperty = x.GetType().GetProperty("value"); 
       valueProperty.SetValue(x, value); 
      } 
      return true; 
     } 

     public T GetValue<T>(T i) 
     { 
      return (T)Convert.ChangeType(i, typeof(T)); 
     } 

     public static T JustValue<T>(Mycapsule<int, T> i) 
     { 
      return i.value; 
     } 
    } 
    //Outside the MainClass inside the same namespace 
    public class Mycapsule<KT, T> 
    { 
     public KT id { get; set; } 
     public T value { get; set; } 
     public int p; // and more 

    } 
}