&引用；商店「；以后在C#中使用的类型参数？

我正在我的应用程序中创建一个设置对象，用于存储用户定义的设置等等。我计划为我的设置字段使用各种数据类型（整数、字符串、枚举、任何可序列化的数据）

如果可能的话，我还想用一种类型安全的方式来设置任何设置。我建议的方法是这样做：

Tuple<string, Type> SettingName = new Tuple<string, Type>("NumberOfFoos",
                                                          typeof(**TYPE**));
public void Set(Tuple<string, Type> key, **TYPE** value) { /* Stuff */ }

Tuple SettingName=新的Tuple（“numberofoos”，
类型（**类型**））；
公共无效集（元组键，**类型**值）{/*Stuff*/}

元组实际上是用户将值推送到的“设置”，它包括该设置的键以及该设置的类型。我想知道的是，是否有办法让编译器强制执行，在

Set（）

方法中，

value

的类型与传递给

Set（）

的元组中保存的type对象的类型相同？我提议的方式可能吗？谢谢

编辑：我想到了更多我应该澄清的事情

1） 这是一个静态类，因此我无法序列化整个类，只能序列化其中的成员。因此，我真的不想处理每个字段的序列化。我计划将所有设置值存储在

字典中

并序列化

2）

元组

定义是常量和静态的。我真的把它们看作是typedef类型的东西（我真的应该创建自己的SettingKey结构），用户将其传递到

Set

以指示它们正在更改的字段。Type参数用于强制执行指定类型的

值

public void Set<T>(Tuple<string,T> key, T value) { /* stuff */ }

public void集（元组键，T值）{/*stuff*/}

可能会这样做

public void Set<T>(Tuple<string,T> key, T value) { /* stuff */ }

public void集（元组键，T值）{/*stuff*/}

可能会这样做
好吧，如果你做了类似于
的设置（Tuple，T value）
，你就会得到你想要的设置。我认为编译器可以在使用时推断出
Set（）
中的T，因此您必须编写它

但是您的
Get（）
，必须指定希望返回的类型。
如果您执行类似于
Set（Tuple，T value）
的操作，您将获得设置所需的内容。我认为编译器可以在使用时推断出
Set（）
中的T，因此您必须编写它

但是您的
Get（）
，必须指定希望返回的类型。
最好去掉元组，并使用通用方法：

public void Set<T>(string key, T value);

在
Set
中，您可以使用
typeof（T）
来获取本应传入的
Type
对象。
最好去掉元组，并使用通用方法：

public void Set<T>(string key, T value);

public class Foo
{
  Tuple<string, Type> SettingName = new Tuple<string, Type>("NumberOfFoos",
                                                          typeof(**TYPE**));
  public void Set(Tuple<string, Type> key, object value) 
  {
    if(value.GetType() != SettingsName.Value)
      throw new ArgumentException("value");
  }
}

在
Set
中，您可以使用
typeof（T）
来获取您应该传入的
Type
对象。
公共类Foo
public class Foo
{
  Tuple<string, Type> SettingName = new Tuple<string, Type>("NumberOfFoos",
                                                          typeof(**TYPE**));
  public void Set(Tuple<string, Type> key, object value) 
  {
    if(value.GetType() != SettingsName.Value)
      throw new ArgumentException("value");
  }
}

{
元组设置名称=新元组（“numberofoos”，
类型（**类型**））；
公共无效集（元组键、对象值）
{
if（value.GetType（）！=设置名称.value）
抛出新的ArgumentException（“值”）；
}
}

不过，您最好像其他答案一样使用泛型。
公共类Foo
{
元组设置名称=新元组（“numberofoos”，
类型（**类型**））；
公共无效集（元组键、对象值）
{
if（value.GetType（）！=设置名称.value）
抛出新的ArgumentException（“值”）；
}
}

不过，您最好像其他答案一样使用泛型。
为什么不简单地向设置对象添加强类型属性呢？e、 g.
public int numberofoos{get{}set{…}
并在getter和setter中调用公共序列化和反序列化代码

如果您这样做，您的设置对象将不会公开其内部工作方式，并且您对其具有完全的intellisense支持。
为什么不简单地向设置对象添加强类型属性？e、 g.
public int numberofoos{get{}set{…}
并在getter和setter中调用公共序列化和反序列化代码

如果您这样做，您的设置对象就不会公开它在内部的工作方式，并且您对它有完全的intellisense支持。
我认为您根本不需要处理
类型。像这样的东西够好吗

class Settings {
  public static int Foo { 
    get { return (int)_map["Foo"]; }
    set { _map["Foo"] = value; }
  }
  public static string Bar {
    get { return (string)_map["Foo"]; }
    set { _map["Foo"] = value; }
  }
  // ...
  private static Dictionary<string, object> _map = 
    new Dictionary<string, object>();
}

类设置{
公共静态int Foo{
获取{return（int）u映射[“Foo”]；}
设置{u map[“Foo”]=value；}
}
公共静态字符串栏{
获取{return（string）u映射[“Foo”]；}
设置{u map[“Foo”]=value；}
}
// ...
专用静态字典_映射=
新字典（）；
}

然后将字典序列化。您甚至可以使用一些来创建这个类。
我认为您根本不需要处理
类型。像这样的东西够好吗

class Settings {
  public static int Foo { 
    get { return (int)_map["Foo"]; }
    set { _map["Foo"] = value; }
  }
  public static string Bar {
    get { return (string)_map["Foo"]; }
    set { _map["Foo"] = value; }
  }
  // ...
  private static Dictionary<string, object> _map = 
    new Dictionary<string, object>();
}

类设置{
公共静态int Foo{
获取{return（int）u映射[“Foo”]；}
设置{u map[“Foo”]=value；}
}
公共静态字符串栏{
获取{return（string）u映射[“Foo”]；}
设置{u map[“Foo”]=value；}
}
// ...
专用静态字典_映射=
新字典（）；
}

然后将字典序列化。您甚至可以使用一些来创建这个类。
好吧，我还想避免为我的60个左右的设置字段中的每一个设置一个私有numberofoos字段和一个单独的numberofoos属性。我计划使用字典来存储所有设置，基于键。检索值时我必须强制转换，但这就是为什么我想使用这样的类型。您可以将它们都设置为自动属性，例如
public int numberofoos{get；set；}
add要进行序列化，您可以向类中添加
[DataContract]
，然后添加
[Da]