blocks|key|1577599|text|这是没有办法的。Nullable和您的方法一样，都被限制为只能使用值类型作为其参数。字符串是引用类型，因此与此声明不兼容。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1577600|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

There is no way around this. Nullable, as well as your method, is constrained to using only value types as it's argument. String is a reference type and hence is incompatible with this declaration.

blocks|key|1362453|text|您可能想要尝试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1362454|TypeConverter+conv+=+TypeDescriptor.GetConverter(typeof(int));
conv.ConvertFrom(mystring);|code-block|syntax|javascript|1362455|执行您自己的null检查并在必要时返回int?。您还需要将其包装在try+{}中|offset|length|style|CODE|1362456|entityMap^0|0|0|J|4|X|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

You might want to try:

<pre><code>TypeConverter conv = TypeDescriptor.GetConverter(typeof(int));
conv.ConvertFrom(mystring);
</code></pre>

do your own null check and return <code>int?</code> if necessary. You'll also want to wrap that in a <code>try {}</code>

blocks|key|1362521|text|这样如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1362522|double?+amount+=+string.IsNullOrEmpty(strAmount)+?+(double?)null+:+Convert.ToDouble(strAmount);|code-block|syntax|javascript|1362523|​|1362524|当然，这没有考虑到转换失败。|1362525|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

What about this:
<pre><code>
double? amount = string.IsNullOrEmpty(strAmount) ? (double?)null : Convert.ToDouble(strAmount);
</pre></code>

Of course, this doesn't take into account the convert failing.

blocks|key|1577763|text|另一件要记住的事情是字符串本身可能是空的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1577764|public+static+Nullable<T>+ToNullable<T>(this+string+s)+where+T:+struct
{
++++Nullable<T>+result+=+new+Nullable<T>();
++++try
++++{
++++++++if+(!string.IsNullOrEmpty(s)+&&+s.Trim().Length+>+0)
++++++++{
++++++++++++TypeConverter+conv+=+TypeDescriptor.GetConverter(typeof(T));
++++++++++++result+=+(T)conv.ConvertFrom(s);
++++++++}
++++}
++++catch+{+}+
++++return+result;
}|code-block|syntax|javascript|1577765|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another thing to keep in mind is that the string itself might be null.

<pre><code>public static Nullable&lt;T&gt; ToNullable&lt;T&gt;(this string s) where T: struct
{
 Nullable&lt;T&gt; result = new Nullable&lt;T&gt;();
 try
 {
 if (!string.IsNullOrEmpty(s) &amp;&amp; s.Trim().Length &gt; 0)
 {
 TypeConverter conv = TypeDescriptor.GetConverter(typeof(T));
 result = (T)conv.ConvertFrom(s);
 }
 }
 catch { } 
 return result;
}
</code></pre>

blocks|key|1362625|text|您可以尝试使用以下扩展方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1362626|public+static+T?+GetValueOrNull<T>(this+string+valueAsString)
++++where+T+:+struct+
{
++++if+(string.IsNullOrEmpty(valueAsString))
++++++++return+null;
++++return+(T)+Convert.ChangeType(valueAsString,+typeof(T));
}|code-block|syntax|javascript|1362627|通过这种方式，您可以执行以下操作：|1362628|double?+amount+=+strAmount.GetValueOrNull<double>();
int?+amount+=+strAmount.GetValueOrNull<int>();
decimal?+amount+=+strAmount.GetValueOrNull<decimal>();|1362629|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You could try using the below extension method:

<pre><code>public static T? GetValueOrNull&lt;T&gt;(this string valueAsString)
 where T : struct 
{
 if (string.IsNullOrEmpty(valueAsString))
 return null;
 return (T) Convert.ChangeType(valueAsString, typeof(T));
}
</code></pre>

This way you can do this:

<pre><code>double? amount = strAmount.GetValueOrNull&lt;double&gt;();
int? amount = strAmount.GetValueOrNull&lt;int&gt;();
decimal? amount = strAmount.GetValueOrNull&lt;decimal&gt;();
</code></pre>

blocks|key|1362651|text|public+static+class+GenericExtension
{
++++public+static+T?+ConvertToNullable<T>(this+String+s)+where+T+:+struct+
++++{
++++++++try
++++++++{
++++++++++++return+(T?)TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(s);
++++++++}
++++++++catch+(Exception)
++++++++{
++++++++++++return+null;
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1362652|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static class GenericExtension
{
 public static T? ConvertToNullable&lt;T&gt;(this String s) where T : struct 
 {
 try
 {
 return (T?)TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(s);
 }
 catch (Exception)
 {
 return null;
 }
 }
}
</code></pre>

blocks|key|1362688|text|试试看..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1362689|public+delegate+bool+TryParseDelegate<T>(string+data,+out+T+output);

public+static+T?+ToNullablePrimitive<T>(this+string+data,+
++++TryParseDelegate<T>+func)+where+T:struct
{
++++string.IsNullOrEmpty(data)+return+null;

++++T+output;

++++if+(func(data,+out+output))
++++{
++++++++return+(T?)output;
++++}

++++return+null;
}|code-block|syntax|javascript|1362690|然后这样叫它..。|1362691|void+doStuff()
{
++++string+foo+=+"1.0";

++++double?+myDouble+=+foo.ToNullablePrimitive<double>(double.TryParse);

++++foo+=+"1";

++++int?+myInt+=+foo.ToNullablePrimitive<int>(int.TryParse);

++++foo+=+"haha";

++++int?+myInt2+=+foo.ToNullablePrimitive<int>(int.TryParse);
}|1362692|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Give this a shot...

<pre><code>public delegate bool TryParseDelegate&lt;T&gt;(string data, out T output);

public static T? ToNullablePrimitive&lt;T&gt;(this string data, 
 TryParseDelegate&lt;T&gt; func) where T:struct
{
 string.IsNullOrEmpty(data) return null;

 T output;

 if (func(data, out output))
 {
 return (T?)output;
 }

 return null;
}
</code></pre>

Then call it like this...

<pre><code>void doStuff()
{
 string foo = "1.0";

 double? myDouble = foo.ToNullablePrimitive&lt;double&gt;(double.TryParse);

 foo = "1";

 int? myInt = foo.ToNullablePrimitive&lt;int&gt;(int.TryParse);

 foo = "haha";

 int? myInt2 = foo.ToNullablePrimitive&lt;int&gt;(int.TryParse);
}
</code></pre>

blocks|key|1577977|text|我写了这个泛型类型转换器。它可以处理Nullable和标准值，可以在所有可转换类型之间进行转换，而不仅仅是string。它可以处理您所期望的各种场景(默认值、空值、其他值等)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1577978|我已经在几十个生产程序中使用了大约一年，所以它应该是相当可靠的。|1577979|++++public+static+T+To<T>(this+IConvertible+obj)
++++{
++++++++Type+t+=+typeof(T);

++++++++if+(t.IsGenericType
++++++++++++&&+(t.GetGenericTypeDefinition()+==+typeof(Nullable<>)))
++++++++{
++++++++++++if+(obj+==+null)
++++++++++++{
++++++++++++++++return+(T)(object)null;
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++return+(T)Convert.ChangeType(obj,+Nullable.GetUnderlyingType(t));
++++++++++++}
++++++++}
++++++++else
++++++++{
++++++++++++return+(T)Convert.ChangeType(obj,+t);
++++++++}
++++}

++++public+static+T+ToOrDefault<T>
+++++++++++++++++(this+IConvertible+obj)
++++{
++++++++try
++++++++{
++++++++++++return+To<T>(obj);
++++++++}
++++++++catch
++++++++{
++++++++++++return+default(T);
++++++++}
++++}

++++public+static+bool+ToOrDefault<T>
++++++++++++++++++++++++(this+IConvertible+obj,
+++++++++++++++++++++++++out+T+newObj)
++++{
++++++++try
++++++++{
++++++++++++newObj+=+To<T>(obj);
++++++++++++return+true;
++++++++}
++++++++catch
++++++++{
++++++++++++newObj+=+default(T);
++++++++++++return+false;
++++++++}
++++}

++++public+static+T+ToOrOther<T>
+++++++++++++++++++++++++++(this+IConvertible+obj,
+++++++++++++++++++++++++++T+other)
++++{
++++++++try
++++++++{
++++++++++++return+To<T>(obj);
++++++++}
++++++++catch
++++++++{
++++++++++++return+other;
++++++++}
++++}

++++public+static+bool+ToOrOther<T>
+++++++++++++++++++++++++++++(this+IConvertible+obj,
+++++++++++++++++++++++++++++out+T+newObj,
+++++++++++++++++++++++++++++T+other)
++++{
++++++++try
++++++++{
++++++++++++newObj+=+To<T>(obj);
++++++++++++return+true;
++++++++}
++++++++catch
++++++++{
++++++++++++newObj+=+other;
++++++++++++return+false;
++++++++}
++++}

++++public+static+T+ToOrNull<T>
++++++++++++++++++++++++++(this+IConvertible+obj)
++++++++++++++++++++++++++where+T+:+class
++++{
++++++++try
++++++++{
++++++++++++return+To<T>(obj);
++++++++}
++++++++catch
++++++++{
++++++++++++return+null;
++++++++}
++++}

++++public+static+bool+ToOrNull<T>
++++++++++++++++++++++(this+IConvertible+obj,
++++++++++++++++++++++out+T+newObj)
++++++++++++++++++++++where+T+:+class
++++{
++++++++try
++++++++{
++++++++++++newObj+=+To<T>(obj);
++++++++++++return+true;
++++++++}
++++++++catch
++++++++{
++++++++++++newObj+=+null;
++++++++++++return+false;
++++++++}
++++}|code-block|syntax|javascript|1577980|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I wrote this generic type converter. It works with Nullable and standard values, converting between all convertible types - not just string. It handles all sorts of scenarios that you'd expect (default values, null values, other values, etc...)

I've been using this for about a year in dozens of production programs, so it should be pretty solid.

<pre><code> public static T To&lt;T&gt;(this IConvertible obj)
 {
 Type t = typeof(T);

 if (t.IsGenericType
 &amp;&amp; (t.GetGenericTypeDefinition() == typeof(Nullable&lt;&gt;)))
 {
 if (obj == null)
 {
 return (T)(object)null;
 }
 else
 {
 return (T)Convert.ChangeType(obj, Nullable.GetUnderlyingType(t));
 }
 }
 else
 {
 return (T)Convert.ChangeType(obj, t);
 }
 }

 public static T ToOrDefault&lt;T&gt;
 (this IConvertible obj)
 {
 try
 {
 return To&lt;T&gt;(obj);
 }
 catch
 {
 return default(T);
 }
 }

 public static bool ToOrDefault&lt;T&gt;
 (this IConvertible obj,
 out T newObj)
 {
 try
 {
 newObj = To&lt;T&gt;(obj);
 return true;
 }
 catch
 {
 newObj = default(T);
 return false;
 }
 }

 public static T ToOrOther&lt;T&gt;
 (this IConvertible obj,
 T other)
 {
 try
 {
 return To&lt;T&gt;(obj);
 }
 catch
 {
 return other;
 }
 }

 public static bool ToOrOther&lt;T&gt;
 (this IConvertible obj,
 out T newObj,
 T other)
 {
 try
 {
 newObj = To&lt;T&gt;(obj);
 return true;
 }
 catch
 {
 newObj = other;
 return false;
 }
 }

 public static T ToOrNull&lt;T&gt;
 (this IConvertible obj)
 where T : class
 {
 try
 {
 return To&lt;T&gt;(obj);
 }
 catch
 {
 return null;
 }
 }

 public static bool ToOrNull&lt;T&gt;
 (this IConvertible obj,
 out T newObj)
 where T : class
 {
 try
 {
 newObj = To&lt;T&gt;(obj);
 return true;
 }
 catch
 {
 newObj = null;
 return false;
 }
 }
</code></pre>

blocks|key|1362965|text|我喜欢Joel的答案，但我稍微修改了一下，因为我不喜欢吃异常。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1362966|++++///+<summary>
++++///+Converts+a+string+to+the+specified+nullable+type.
++++///+</summary>
++++///+<typeparam+name="T">The+type+to+convert+to</typeparam>
++++///+<param+name="s">The+string+to+convert</param>
++++///+<returns>The+nullable+output</returns>
++++public+static+T?+ToNullable<T>(this+string+s)+where+T+:+struct
++++{
++++++++if+(string.IsNullOrWhiteSpace(s))
++++++++++++return+null;

++++++++TypeConverter+conv+=+TypeDescriptor.GetConverter(typeof+(T));
++++++++return+(T)+conv.ConvertFrom(s);
++++}

++++///+<summary>
++++///+Attempts+to+convert+a+string+to+the+specified+nullable+primative.
++++///+</summary>
++++///+<typeparam+name="T">The+primitive+type+to+convert+to</typeparam>
++++///+<param+name="data">The+string+to+convert</param>
++++///+<param+name="output">The+nullable+output</param>
++++///+<returns>
++++///+True+if+conversion+is+successfull,+false+otherwise.++Null+and+whitespace+will
++++///+be+converted+to+null+and+return+true.
++++///+</returns>
++++public+static+bool+TryParseNullable<T>(this+string+data,+out+T?+output)+where+T+:+struct
++++{
++++++++try
++++++++{
++++++++++++output+=+data.ToNullable<T>();
++++++++++++return+true;
++++++++}
++++++++catch
++++++++{
++++++++++++output+=+null;
++++++++++++return+false;
++++++++}
++++}|code-block|syntax|javascript|1362967|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I like Joel's answer, but I've modified it slightly as I'm not a fan of eating exceptions.

<pre><code> /// &lt;summary&gt;
 /// Converts a string to the specified nullable type.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;The type to convert to&lt;/typeparam&gt;
 /// &lt;param name="s"&gt;The string to convert&lt;/param&gt;
 /// &lt;returns&gt;The nullable output&lt;/returns&gt;
 public static T? ToNullable&lt;T&gt;(this string s) where T : struct
 {
 if (string.IsNullOrWhiteSpace(s))
 return null;

 TypeConverter conv = TypeDescriptor.GetConverter(typeof (T));
 return (T) conv.ConvertFrom(s);
 }

 /// &lt;summary&gt;
 /// Attempts to convert a string to the specified nullable primative.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;The primitive type to convert to&lt;/typeparam&gt;
 /// &lt;param name="data"&gt;The string to convert&lt;/param&gt;
 /// &lt;param name="output"&gt;The nullable output&lt;/param&gt;
 /// &lt;returns&gt;
 /// True if conversion is successfull, false otherwise. Null and whitespace will
 /// be converted to null and return true.
 /// &lt;/returns&gt;
 public static bool TryParseNullable&lt;T&gt;(this string data, out T? output) where T : struct
 {
 try
 {
 output = data.ToNullable&lt;T&gt;();
 return true;
 }
 catch
 {
 output = null;
 return false;
 }
 }
</code></pre>

blocks|key|1363014|text|有一个通用的解决方案(适用于任何类型)。可用性很好，但实现还需要改进：http://cleansharp.de/wordpress/2011/05/generischer-typeconverter/|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1363015|这使您可以像这样编写非常干净的代码：|1363016|string+value+=+null;
int?+x+=+value.ConvertOrDefault<int?>();|code-block|syntax|javascript|1363017|还有：|1363018|object+obj+=+1;++

string+value+=+null;
int+x+=+5;
if+(value.TryConvert(out+x))
++++Console.WriteLine("TryConvert+example:+"+%2B+x);+

bool+boolean+=+"false".ConvertOrDefault<bool>();
bool?+nullableBoolean+=+"".ConvertOrDefault<bool?>();
int+integer+=+obj.ConvertOrDefault<int>();
int+negativeInteger+=+"-12123".ConvertOrDefault<int>();
int?+nullableInteger+=+value.ConvertOrDefault<int?>();
MyEnum+enumValue+=+"SecondValue".ConvertOrDefault<MyEnum>();

MyObjectBase+myObject+=+new+MyObjectClassA();
MyObjectClassA+myObjectClassA+=+myObject.ConvertOrDefault<MyObjectClassA>();|1363019|entityMap|0|LINK|mutability|MUTABLE|url|http://cleansharp.de/wordpress/2011/05/generischer-typeconverter/^0|Z|1T|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

There is a generic solution (for any type). Usability is good, but implementation should be improved:
<a href="http://cleansharp.de/wordpress/2011/05/generischer-typeconverter/" rel="nofollow">http://cleansharp.de/wordpress/2011/05/generischer-typeconverter/</a>

This allows you to write very clean code like this:

<pre><code>string value = null;
int? x = value.ConvertOrDefault&lt;int?&gt;();
</code></pre>

and also:

<pre><code>object obj = 1; 

string value = null;
int x = 5;
if (value.TryConvert(out x))
 Console.WriteLine("TryConvert example: " + x); 

bool boolean = "false".ConvertOrDefault&lt;bool&gt;();
bool? nullableBoolean = "".ConvertOrDefault&lt;bool?&gt;();
int integer = obj.ConvertOrDefault&lt;int&gt;();
int negativeInteger = "-12123".ConvertOrDefault&lt;int&gt;();
int? nullableInteger = value.ConvertOrDefault&lt;int?&gt;();
MyEnum enumValue = "SecondValue".ConvertOrDefault&lt;MyEnum&gt;();

MyObjectBase myObject = new MyObjectClassA();
MyObjectClassA myObjectClassA = myObject.ConvertOrDefault&lt;MyObjectClassA&gt;();
</code></pre>

blocks|key|1363069|text|您可以对对象使用以下代码，但不幸的是，这不适用于字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1363070|double?+amount+=+(double?)someObject;|code-block|syntax|javascript|1363071|我使用它将会话变量包装在属性中(在基页上)..所以我的实际用法是(在我的基本页面中)：|1363072|public+int?+OrganisationID
{
++++get+{+return+(int?)Session[Constants.Session_Key_OrganisationID];+}
++++set+{+Session[Constants.Session_Key_OrganisationID]+=+value;+}
}|1363073|我能够检查页面逻辑中的null：|1363074|if+(base.OrganisationID+==+null)
++++//+do+stuff|1363075|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You can use the following with objects, unfortunately this does not work with strings though.

<pre><code>double? amount = (double?)someObject;
</code></pre>

I use it for wrapping a session variable in a property (on a base page).. so my actual usage is (in my base page):

<pre><code>public int? OrganisationID
{
 get { return (int?)Session[Constants.Session_Key_OrganisationID]; }
 set { Session[Constants.Session_Key_OrganisationID] = value; }
}
</code></pre>

I'm able to check for null in page logic:

<pre><code>if (base.OrganisationID == null)
 // do stuff
</code></pre>

blocks|key|1363177|text|我的无名类型示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1363178|private+object+ConvertNullable(object+value,+Type+nullableType)
{
++++Type+resultType+=+typeof(Nullable<>).MakeGenericType(nullableType.GetGenericArguments());
++++return+Activator.CreateInstance(resultType,+Convert.ChangeType(value,+nullableType.GetGenericArguments()[0]));
}

...

Type+anonimousType+=+typeof(Nullable<int>);
object+nullableInt1+=+ConvertNullable("5",+anonimousType);
//+or+evident+Type
Nullable<int>+nullableInt2+=+(Nullable<int>)ConvertNullable("5",+typeof(Nullable<int>));|code-block|syntax|javascript|1363179|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My example for anonimous types:

<pre><code>private object ConvertNullable(object value, Type nullableType)
{
 Type resultType = typeof(Nullable&lt;&gt;).MakeGenericType(nullableType.GetGenericArguments());
 return Activator.CreateInstance(resultType, Convert.ChangeType(value, nullableType.GetGenericArguments()[0]));
}

...

Type anonimousType = typeof(Nullable&lt;int&gt;);
object nullableInt1 = ConvertNullable("5", anonimousType);
// or evident Type
Nullable&lt;int&gt; nullableInt2 = (Nullable&lt;int&gt;)ConvertNullable("5", typeof(Nullable&lt;int&gt;));
</code></pre>

blocks|key|1363260|text|这里有一些基于公认的答案的东西。我删除了try/catch，以确保所有异常都不会被吞并和处理。还要确保返回变量(在accepted中)不会被无缘无故地初始化两次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1363261|public+static+Nullable<T>+ToNullable<T>(this+string+s)+where+T:+struct
{
++++if+(!string.IsNullOrWhiteSpace(s))
++++{
++++++++TypeConverter+conv+=+TypeDescriptor.GetConverter(typeof(T));

++++++++return+(T)conv.ConvertFrom(s);
++++}

++++return+default(Nullable<T>);
}|code-block|syntax|javascript|1363262|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's something based on accepted answer. I removed the try/catch to make sure all the exceptions are not swallowed and not dealt with. Also made sure that the return variable (in accepted answer) is never initialized twice for nothing.

<pre><code>public static Nullable&lt;T&gt; ToNullable&lt;T&gt;(this string s) where T: struct
{
 if (!string.IsNullOrWhiteSpace(s))
 {
 TypeConverter conv = TypeDescriptor.GetConverter(typeof(T));

 return (T)conv.ConvertFrom(s);
 }

 return default(Nullable&lt;T&gt;);
}
</code></pre>

blocks|key|1578537|text|让我们在堆栈中再添加一个类似的解决方案。它还可以解析枚举，而且看起来很不错。非常安全。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1578538|///+<summary>
++++///+<para>More+convenient+than+using+T.TryParse(string,+out+T).+
++++///+Works+with+primitive+types,+structs,+and+enums.
++++///+Tries+to+parse+the+string+to+an+instance+of+the+type+specified.
++++///+If+the+input+cannot+be+parsed,+null+will+be+returned.
++++///+</para>
++++///+<para>
++++///+If+the+value+of+the+caller+is+null,+null+will+be+returned.
++++///+So+if+you+have+"string+s+=+null;"+and+then+you+try+"s.ToNullable...",
++++///+null+will+be+returned.+No+null+exception+will+be+thrown.+
++++///+</para>
++++///+<author>Contributed+by+Taylor+Love+(Pangamma)</author>
++++///+</summary>
++++///+<typeparam+name="T"></typeparam>
++++///+<param+name="p_self"></param>
++++///+<returns></returns>
++++public+static+T?+ToNullable<T>(this+string+p_self)+where+T+:+struct
++++{
++++++++if+(!string.IsNullOrEmpty(p_self))
++++++++{
++++++++++++var+converter+=+System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
++++++++++++if+(converter.IsValid(p_self))+return+(T)converter.ConvertFromString(p_self);
++++++++++++if+(typeof(T).IsEnum)+{+T+t;+if+(Enum.TryParse<T>(p_self,+out+t))+return+t;}
++++++++}

++++++++return+null;
++++}|code-block|syntax|javascript|1578539|https://github.com/Pangamma/PangammaUtilities-CSharp/blob/master/PangammaUtilities/Extensions/ToNullableStringExtension.cs|offset|length|1578540|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|3E|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

Let's add one more similar solution to the stack. This one also parses enums, and it looks nice. Very safe. 

<pre><code>/// &lt;summary&gt;
 /// &lt;para&gt;More convenient than using T.TryParse(string, out T). 
 /// Works with primitive types, structs, and enums.
 /// Tries to parse the string to an instance of the type specified.
 /// If the input cannot be parsed, null will be returned.
 /// &lt;/para&gt;
 /// &lt;para&gt;
 /// If the value of the caller is null, null will be returned.
 /// So if you have "string s = null;" and then you try "s.ToNullable...",
 /// null will be returned. No null exception will be thrown. 
 /// &lt;/para&gt;
 /// &lt;author&gt;Contributed by Taylor Love (Pangamma)&lt;/author&gt;
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;&lt;/typeparam&gt;
 /// &lt;param name="p_self"&gt;&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public static T? ToNullable&lt;T&gt;(this string p_self) where T : struct
 {
 if (!string.IsNullOrEmpty(p_self))
 {
 var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
 if (converter.IsValid(p_self)) return (T)converter.ConvertFromString(p_self);
 if (typeof(T).IsEnum) { T t; if (Enum.TryParse&lt;T&gt;(p_self, out t)) return t;}
 }

 return null;
 }
</code></pre>

<a href="https://github.com/Pangamma/PangammaUtilities-CSharp/blob/master/PangammaUtilities/Extensions/ToNullableStringExtension.cs" rel="nofollow noreferrer">https://github.com/Pangamma/PangammaUtilities-CSharp/blob/master/PangammaUtilities/Extensions/ToNullableStringExtension.cs</a>

I am attempting to do some data conversion. Unfortunately, much of the data is in strings, where it should be int's or double, etc... 

So what I've got is something like:

<pre><code>double? amount = Convert.ToDouble(strAmount);
</code></pre>

The problem with this approach is if strAmount is empty, if it's empty I want it to amount to be null, so when I add it into the database the column will be null. So I ended up writing this:

<pre><code>double? amount = null;
if(strAmount.Trim().Length&gt;0)
{
 amount = Convert.ToDouble(strAmount);
}
</code></pre>

Now this works fine, but I now have five lines of code instead of one. This makes things a little more difficult to read, especially when I have a large amount of columns to convert.

I thought I'd use an extension to the string class and generic's to pass in the type, this is because it could be a double, or an int, or a long. So I tried this:

<pre><code>public static class GenericExtension
{
 public static Nullable&lt;T&gt; ConvertToNullable&lt;T&gt;(this string s, T type) where T: struct
 {
 if (s.Trim().Length &gt; 0)
 {
 return (Nullable&lt;T&gt;)s;
 }
 return null;
 }
}
</code></pre>

But I get the error: Cannot convert type 'string' to 'T?'

Is there a way around this? I am not very familiar with creating methods using generics.

Convert string to nullable type (int, double, etc...)

数据转换

数据库

我正在尝试进行一些数据转换。不幸的是，大部分数据都在字符串中，应该是整型或双精度型，等等。所以我得到的是这样的：double? amount = Convert.ToDouble(strAmount);这种方法的问题是，如果strAmount为空，如果它为空，我希望它为null，所以当我将其添加到数据库中时，列将为nu...

问将字符串转换为可以为空的类型(int、double等...)
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将字符串转换为可以为空的类型(int、double等...)EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将字符串转换为可以为空的类型(int、double等...)
EN