ジェネリックTryParse


196

'TryParse'を使用して文字列が指定されたタイプかどうかを確認する汎用拡張を作成しようとしています。

public static bool Is<T>(this string input)
{
    T notUsed;
    return T.TryParse(input, out notUsed);
}

シンボル「TryParse」を解決できないため、これはコンパイルされません

私が理解しているように、「TryParse」はどのインターフェースにも含まれていません。

これはまったく可能ですか?

更新:

以下の答えを使用して私は思いつきました:

public static bool Is<T>(this string input)
{
    try
    {
        TypeDescriptor.GetConverter(typeof(T)).ConvertFromString(input);
    }
    catch
    {
        return false;
    }

    return true;
}

それは非常にうまく機能しますが、そのように例外を使用することは私には正しくないと思います。

Update2:

ジェネリックを使用するのではなく、タイプを渡すように変更されました。

public static bool Is(this string input, Type targetType)
{
    try
    {
        TypeDescriptor.GetConverter(targetType).ConvertFromString(input);
        return true;
    }
    catch
    {
        return false;
    }
}

1
この一般的なケースでは、例外的な処理に対処する必要があると思います。ケースを追加してintやdoubleのようなものをチェックしてから、特定のTryParseメソッドを使用することもできますが、他のタイプをキャッチするには、これに頼る必要があります。
luke

1
ジェネリックの使用は不要です。Typeをパラメーターとして渡すだけです。public static bool Is(this string input、Type targetType)。そのように呼び出すと、少しきれいに見えます:x.Is(typeof(int))-VS- x.Is <int>()
mikesigs

2
コンバーターにIsValidメソッドがあり、変換に問題があるかどうかを確認できます。以下の方法を使用しましたが、問題なく動作するようです。 protected Boolean TryParse<T>(Object value, out T result) { result = default(T); var convertor = TypeDescriptor.GetConverter(typeof(T)); if (convertor == null || !convertor.IsValid(value)) { return false; } result = (T)convertor.ConvertFrom(value); return true; }
CastroXXL 2011

@CastroXXLこの質問に関心をお寄せいただきありがとうございます。ただし、メソッドはオブジェクトタイプでは有用ですが(ただし、例外をキャッチするConvertFrom(value)には、メソッドをtry-catchブロックでラップする必要があります
Piers Myers

2
(targetType == null)かどうかを確認する必要があります。コードで最初に使用するとスローされる可能性がありますが、その例外はキャッチによって飲み込まれるためです。
Nick Strupat

回答:


183

TypeDescriptorクラスを使用する必要があります。

public static T Convert<T>(this string input)
{
    try
    {
        var converter = TypeDescriptor.GetConverter(typeof(T));
        if(converter != null)
        {
            // Cast ConvertFromString(string text) : object to (T)
            return (T)converter.ConvertFromString(input);
        }
        return default(T);
    }
    catch (NotSupportedException)
    {
        return default(T);
    }
}

3
復活して申し訳ありませんが、GetConverterはnullを返しますか?もしそうなら、おそらく本質的に静かに失敗して何かを返すのではなく、例外がスローされるべきだと思います。(typeconverterを定義していない)自分のクラスで試したところ、GetConverterからコンバーターを取得しましたが、ConvertFromStringがNotSupportedExceptionをスローしました。
user420667

3
@ user420667、文字列から変換する前に、CanConvertFrom(typeof(string))の結果を確認する必要があると思います。TypeConverterは文字列からの変換をサポートしない場合があります。
ルーベンボンド

3
if(typeof(T).IsEnum){return(T)Enum.Parse(typeof(T)、input);を追加できます。} [すべてのEnumタイプのかなり一般的なショートカットとして]コンバータを取得する前に。より複雑な型ではなく、列挙型を実行する頻度に依存すると思います。
Jesse Chisholm

10
なぜこれが回答としてマークされ、要求されたもの(一般的なTry Parse)が実装されていないのにそれほど賛成されているのか理解できません。TryParseメソッドの主な目的は、解析を実行しようとしたときに例外をスローせず、解析が失敗し、このソリューションがそれだけを提供できない場合のパフォーマンスへの影響がはるかに少ないことです。
Florin Dumitrescu 2014

2
これに関する1つの問題は、Tがintで、入力がint.MaxValueよりも大きい場合、System.Exceptionを内部例外としてSystem.OverFlowExceptionでスローすることです。したがって、OverflowExceptionを予期している場合は、スローされたExceptionを問い合わせない限り、それを取得できません。その理由は、ConvertFromStringがOverflowExceptionをスローし、次にTへのキャストがSystem.Exceptionをスローするためです。
Trevor

78

最近、汎用的なTryParseも必要になりました。これが私が思いついたものです。

public static T? TryParse<T>(string value, TryParseHandler<T> handler) where T : struct
{
    if (String.IsNullOrEmpty(value))
        return null;
    T result;
    if (handler(value, out result))
        return result;
    Trace.TraceWarning("Invalid value '{0}'", value);
    return null;
}

public delegate bool TryParseHandler<T>(string value, out T result);

そして、それは単にこのように呼び出すことの問題です:

var value = TryParse<int>("123", int.TryParse);
var value2 = TryParse<decimal>("123.123", decimal.TryParse);

3
数か月後に再びこの投稿に遭遇し、それを再度使用しているときに、メソッドがTハンドラーから推測できないことに気付きTました。いつ呼び出すかを明示的に指定する必要があります。私は好奇心旺盛ですが、なぜそれが推論できないのTですか?
Nick Strupat

25
なぜこの関数を使いたいのですか?値を解析するために呼び出す関数がわかっている場合は、直接呼び出すだけではどうですか。これはすでに正しい入力タイプを認識しており、ジェネリックの必要はありません。このソリューションは、TryParseHandlerがないタイプでは機能しません。
xxbbcc 2013年

2
@xxbbcc:TryParseは解析が成功したかどうかを示すブール値を返すため、この関数を使用したいと思います。出力パラメーターを介して解析された値を返します。SomeMethod(TryParse<int>(DollarTextbox.Text, int.TryParse))からの結果をキャッチする出力変数を作成せずに、このようなことをしたい場合がありますint.TryParse。ただし、関数に型を推定させることについてのニックの感情には同意します。
Walter Stabosz 2013

1
非常に効率的な方法です。強くお勧めします。
Vladimir Kocjancic

3
3番目のパラメーターとしてデフォルト値をお勧めします。これにより、Tを推論できない問題が修正されます。また、文字列値が無効な場合に必要な値を決定できます。たとえば、-1は無効を意味する場合があります。public static T TryParse <T>(string value、TryParseHandler <T> handler、T defaultValue)
Rhyous

33

フロー制御にtry / catchesを使用するのはひどいポリシーです。例外をスローすると、ランタイムが例外を回避する間にパフォーマンスが低下します。代わりに、変換する前にデータを検証します。

var attemptedValue = "asdfasdsd";
var type = typeof(int);
var converter = TypeDescriptor.GetConverter(type);
if (converter != null &&  converter.IsValid(attemptedValue))
    return converter.ConvertFromString(attemptedValue);
else
    return Activator.CreateInstance(type);

2
converter != null常に正しいというResharperの通知を受け取っているので、コードから削除できます。
ErikE 2014

5
@ErikE私は常にこれらのReSharper警告を信頼しているわけではありません。多くの場合、彼らは実行時に何が起こるかを見ることができません。
ProfK 2014年

1
@ProfK MSDNは、nullを返す可能性があるとは言いませんmsdn.microsoft.com/en-us/library/ewtxwhzx.aspx
danio

@danio私は一般的に、そのようなR#警告と私の経験を共有していました。私は確かにこの場合は間違っていたことを示唆していませんでした。
ProfK 2017年

14

TryParseを使用するように設定されている場合は、リフレクションを使用して次のように実行できます。

public static bool Is<T>(this string input)
{
    var type = typeof (T);
    var temp = default(T);
    var method = type.GetMethod(
        "TryParse",
        new[]
            {
                typeof (string),
                Type.GetType(string.Format("{0}&", type.FullName))
            });
    return (bool) method.Invoke(null, new object[] {input, temp});
}

これはとてもクールで、とにかく気に入らなかった例外を取り除くことができます。まだ少し複雑ですが。
ピアスマイヤーズ

6
素晴らしい解決策ですが、リフレクションを含むすべての回答(特に、内部ループから簡単に呼び出すことができるユーティリティメソッド)には、パフォーマンスに関する免責事項が必要です。参照:stackoverflow.com/questions/25458/how-costly-is-net-reflection
Patrick M

はぁ。したがって、選択肢は、(1)コードフロー制御の例外を使用する、(2)リフレクションを使用し、速度を犠牲にすることです。私は@PiersMyersに同意します-どちらの選択も理想的ではありません。彼らが両方ともうまくいくこと。:)
Jesse Chisholm

私はあなたが交換することができると思いますType.GetType(string.Format(...))type.MakeByRefType()
Drew Noakes

3
メソッドは、タイプごとに1回だけ反映される必要があり、呼び出しごとに1回反映される必要はありません。これを静的メンバー変数を持つジェネリッククラスにすると、最初のリフレクションの出力を再利用できます。
Andrew Hill

7

これは、ジェネリック型ごとに静的コンストラクターを使用するため、特定の型で最初に呼び出すときに、コストのかかる作業を実行するだけで済みます。これは、TryParseメソッドを持つシステム名前空間のすべてのタイプを処理します。列挙型を除いて、それら(構造体)のそれぞれのnull許容バージョンでも機能します。

    public static bool TryParse<t>(this string Value, out t result)
    {
        return TryParser<t>.TryParse(Value.SafeTrim(), out result);
    }
    private delegate bool TryParseDelegate<t>(string value, out t result);
    private static class TryParser<T>
    {
        private static TryParseDelegate<T> parser;
        // Static constructor:
        static TryParser()
        {
            Type t = typeof(T);
            if (t.IsEnum)
                AssignClass<T>(GetEnumTryParse<T>());
            else if (t == typeof(bool) || t == typeof(bool?))
                AssignStruct<bool>(bool.TryParse);
            else if (t == typeof(byte) || t == typeof(byte?))
                AssignStruct<byte>(byte.TryParse);
            else if (t == typeof(short) || t == typeof(short?))
                AssignStruct<short>(short.TryParse);
            else if (t == typeof(char) || t == typeof(char?))
                AssignStruct<char>(char.TryParse);
            else if (t == typeof(int) || t == typeof(int?))
                AssignStruct<int>(int.TryParse);
            else if (t == typeof(long) || t == typeof(long?))
                AssignStruct<long>(long.TryParse);
            else if (t == typeof(sbyte) || t == typeof(sbyte?))
                AssignStruct<sbyte>(sbyte.TryParse);
            else if (t == typeof(ushort) || t == typeof(ushort?))
                AssignStruct<ushort>(ushort.TryParse);
            else if (t == typeof(uint) || t == typeof(uint?))
                AssignStruct<uint>(uint.TryParse);
            else if (t == typeof(ulong) || t == typeof(ulong?))
                AssignStruct<ulong>(ulong.TryParse);
            else if (t == typeof(decimal) || t == typeof(decimal?))
                AssignStruct<decimal>(decimal.TryParse);
            else if (t == typeof(float) || t == typeof(float?))
                AssignStruct<float>(float.TryParse);
            else if (t == typeof(double) || t == typeof(double?))
                AssignStruct<double>(double.TryParse);
            else if (t == typeof(DateTime) || t == typeof(DateTime?))
                AssignStruct<DateTime>(DateTime.TryParse);
            else if (t == typeof(TimeSpan) || t == typeof(TimeSpan?))
                AssignStruct<TimeSpan>(TimeSpan.TryParse);
            else if (t == typeof(Guid) || t == typeof(Guid?))
                AssignStruct<Guid>(Guid.TryParse);
            else if (t == typeof(Version))
                AssignClass<Version>(Version.TryParse);
        }
        private static void AssignStruct<t>(TryParseDelegate<t> del)
            where t: struct
        {
            TryParser<t>.parser = del;
            if (typeof(t).IsGenericType
                && typeof(t).GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                return;
            }
            AssignClass<t?>(TryParseNullable<t>);
        }
        private static void AssignClass<t>(TryParseDelegate<t> del)
        {
            TryParser<t>.parser = del;
        }
        public static bool TryParse(string Value, out T Result)
        {
            if (parser == null)
            {
                Result = default(T);
                return false;
            }
            return parser(Value, out Result);
        }
    }

    private static bool TryParseEnum<t>(this string Value, out t result)
    {
        try
        {
            object temp = Enum.Parse(typeof(t), Value, true);
            if (temp is t)
            {
                result = (t)temp;
                return true;
            }
        }
        catch
        {
        }
        result = default(t);
        return false;
    }
    private static MethodInfo EnumTryParseMethod;
    private static TryParseDelegate<t> GetEnumTryParse<t>()
    {
        Type type = typeof(t);

        if (EnumTryParseMethod == null)
        {
            var methods = typeof(Enum).GetMethods(
                BindingFlags.Public | BindingFlags.Static);
            foreach (var method in methods)
                if (method.Name == "TryParse"
                    && method.IsGenericMethodDefinition
                    && method.GetParameters().Length == 2
                    && method.GetParameters()[0].ParameterType == typeof(string))
                {
                    EnumTryParseMethod = method;
                    break;
                }
        }
        var result = Delegate.CreateDelegate(
            typeof(TryParseDelegate<t>),
            EnumTryParseMethod.MakeGenericMethod(type), false)
            as TryParseDelegate<t>;
        if (result == null)
            return TryParseEnum<t>;
        else
            return result;
    }

    private static bool TryParseNullable<t>(string Value, out t? Result)
        where t: struct
    {
        t temp;
        if (TryParser<t>.TryParse(Value, out temp))
        {
            Result = temp;
            return true;
        }
        else
        {
            Result = null;
            return false;
        }
    }

6

このようなものはどうですか?

http://madskristensen.net/post/Universal-data-type-checker.aspxアーカイブ

/// <summary> 
/// Checks the specified value to see if it can be 
/// converted into the specified type. 
/// <remarks> 
/// The method supports all the primitive types of the CLR 
/// such as int, boolean, double, guid etc. as well as other 
/// simple types like Color and Unit and custom enum types. 
/// </remarks> 
/// </summary> 
/// <param name="value">The value to check.</param> 
/// <param name="type">The type that the value will be checked against.</param> 
/// <returns>True if the value can convert to the given type, otherwise false. </returns> 
public static bool CanConvert(string value, Type type) 
{ 
    if (string.IsNullOrEmpty(value) || type == null) return false;
    System.ComponentModel.TypeConverter conv = System.ComponentModel.TypeDescriptor.GetConverter(type);
    if (conv.CanConvertFrom(typeof(string)))
    { 
        try 
        {
            conv.ConvertFrom(value); 
            return true;
        } 
        catch 
        {
        } 
     } 
     return false;
  }

これは非常に簡単にジェネリックメソッドに変換できます。

 public static bool Is<T>(this string value)
 {
    if (string.IsNullOrEmpty(value)) return false;
    var conv = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));

    if (conv.CanConvertFrom(typeof(string)))
    { 
        try 
        {
            conv.ConvertFrom(value); 
            return true;
        } 
        catch 
        {
        } 
     } 
     return false;
}

tryブロックからtrueを返すか、catchブロックからfalseを返すかは重要ですか?私はそうではないと思いますが、この方法で例外を使用することは私には間違っていると感じます...
Piers Myers

3
catchブロックから戻るかどうかは関係ありません。これは同じです。ところで。通常、一般的なcatch句を使用するのはよくありませんcatch { }。ただし、この場合、.NET BaseNumberConverterException変換エラーの場合に基本クラスをスローするため、代替手段はありません。これは非常に残念です。実際、この基本タイプがスローされた場所はまだかなりあります。マイクロソフトがこれらのフレームワークの将来のバージョンで修正することを期待しています。
Steven

スティーブン、ありがとう。
Bob

変換の結果は利用されません。コードは冗長です。
BillW

4

一般的なタイプではできません。

あなたができることは、ITryParsableインターフェースを作成し、このインターフェースを実装するカスタム型にそれを使用することです。

あなたのような基本的なタイプでこれを使用することかかわらず、私は推測intしてDateTime。これらのタイプを変更して新しいインターフェースを実装することはできません。


1
.net 4で動的キーワードを使用することでそれがうまくいくのだろうか?
Pierre-Alain Vigeant 2010年

@Pierre:これはdynamic静的型付けでは機能しないため、C#のキーワードではデフォルトで機能しません。これを処理できる独自の動的オブジェクトを作成できますが、デフォルトではありません。
Steven

4

Charlie Brownがここに投稿したソリューションに触発されて、リフレクションを使用して汎用のTryParseを作成し、オプションで解析された値を出力しました。

/// <summary>
/// Tries to convert the specified string representation of a logical value to
/// its type T equivalent. A return value indicates whether the conversion
/// succeeded or failed.
/// </summary>
/// <typeparam name="T">The type to try and convert to.</typeparam>
/// <param name="value">A string containing the value to try and convert.</param>
/// <param name="result">If the conversion was successful, the converted value of type T.</param>
/// <returns>If value was converted successfully, true; otherwise false.</returns>
public static bool TryParse<T>(string value, out T result) where T : struct {
    var tryParseMethod = typeof(T).GetMethod("TryParse", BindingFlags.Static | BindingFlags.Public, null, new [] { typeof(string), typeof(T).MakeByRefType() }, null);
    var parameters = new object[] { value, null };

    var retVal = (bool)tryParseMethod.Invoke(null, parameters);

    result = (T)parameters[1];
    return retVal;
}

/// <summary>
/// Tries to convert the specified string representation of a logical value to
/// its type T equivalent. A return value indicates whether the conversion
/// succeeded or failed.
/// </summary>
/// <typeparam name="T">The type to try and convert to.</typeparam>
/// <param name="value">A string containing the value to try and convert.</param>
/// <returns>If value was converted successfully, true; otherwise false.</returns>
public static bool TryParse<T>(string value) where T : struct {
    T throwaway;
    var retVal = TryParse(value, out throwaway);
    return retVal;
}

このように呼び出すことができます:

string input = "123";
decimal myDecimal;

bool myIntSuccess = TryParse<int>(input);
bool myDecimalSuccess = TryParse<decimal>(input, out myDecimal);

更新:
また、私が本当に気に入っているYotaXPのソリューションのおかげで、拡張メソッドを使用しないバージョンを作成しましたが、シングルトンがあり、リフレクションを行う必要性を最小限に抑えています。

/// <summary>
/// Provides some extra parsing functionality for value types.
/// </summary>
/// <typeparam name="T">The value type T to operate on.</typeparam>
public static class TryParseHelper<T> where T : struct {
    private delegate bool TryParseFunc(string str, out T result);

    private static TryParseFunc tryParseFuncCached;

    private static TryParseFunc tryParseCached {
        get {
            return tryParseFuncCached ?? (tryParseFuncCached = Delegate.CreateDelegate(typeof(TryParseFunc), typeof(T), "TryParse") as TryParseFunc);
        }
    }

    /// <summary>
    /// Tries to convert the specified string representation of a logical value to
    /// its type T equivalent. A return value indicates whether the conversion
    /// succeeded or failed.
    /// </summary>
    /// <param name="value">A string containing the value to try and convert.</param>
    /// <param name="result">If the conversion was successful, the converted value of type T.</param>
    /// <returns>If value was converted successfully, true; otherwise false.</returns>
    public static bool TryParse(string value, out T result) {
        return tryParseCached(value, out result);
    }

    /// <summary>
    /// Tries to convert the specified string representation of a logical value to
    /// its type T equivalent. A return value indicates whether the conversion
    /// succeeded or failed.
    /// </summary>
    /// <param name="value">A string containing the value to try and convert.</param>
    /// <returns>If value was converted successfully, true; otherwise false.</returns>
    public static bool TryParse(string value) {
        T throwaway;
        return TryParse(value, out throwaway);
    }
}

次のように呼び出します。

string input = "987";
decimal myDecimal;

bool myIntSuccess = TryParseHelper<int>.TryParse(input);
bool myDecimalSuccess = TryParseHelper<decimal>.TryParse(input, out myDecimal);

3

パーティーにはかなり遅れましたが、これが私が思いついたものです。例外なし、1回限り(タイプごと)のリフレクション。

public static class Extensions {
    public static T? ParseAs<T>(this string str) where T : struct {
        T val;
        return GenericHelper<T>.TryParse(str, out val) ? val : default(T?);
    }
    public static T ParseAs<T>(this string str, T defaultVal) {
        T val;
        return GenericHelper<T>.TryParse(str, out val) ? val : defaultVal;
    }

    private static class GenericHelper<T> {
        public delegate bool TryParseFunc(string str, out T result);

        private static TryParseFunc tryParse;
        public static TryParseFunc TryParse {
            get {
                if (tryParse == null)
                    tryParse = Delegate.CreateDelegate(
                        typeof(TryParseFunc), typeof(T), "TryParse") as TryParseFunc;
                return tryParse;
            }
        }
    }
}

ジェネリッククラス内では拡張メソッドを使用できないため、追加のクラスが必要です。これにより、以下に示すように単純な使用が可能になり、タイプが初めて使用されるときにのみリフレクションがヒットします。

"5643".ParseAs<int>()

3

ここに別のオプションがあります。

任意の数のTryParseハンドラーを簡単に登録できるクラスを作成しました。それは私にこれをさせる:

var tp = new TryParser();

tp.Register<int>(int.TryParse);
tp.Register<decimal>(decimal.TryParse);
tp.Register<double>(double.TryParse);

int x;
if (tp.TryParse("42", out x))
{
    Console.WriteLine(x);
};

私は、GET 42コンソールに出力します。

クラスは次のとおりです。

public class TryParser
{
    public delegate bool TryParseDelegate<T>(string s, out T result);

    private Dictionary<Type, Delegate> _tryParsers = new Dictionary<Type, Delegate>();

    public void Register<T>(TryParseDelegate<T> d)
    {
        _tryParsers[typeof(T)] = d;
    }

    public bool Deregister<T>()
    {
        return _tryParsers.Remove(typeof(T));
    }

    public bool TryParse<T>(string s, out T result)
    {
        if (!_tryParsers.ContainsKey(typeof(T)))
        {
            throw new ArgumentException("Does not contain parser for " + typeof(T).FullName + ".");
        }
        var d = (TryParseDelegate<T>)_tryParsers[typeof(T)];
        return d(s, out result);
    }
}

私はこれが好きですが、ジェネリックなしでどのようにそれを行いますか もちろん、ユースケースはリフレクションです。
Sinaesthetic

リフレクションハッカーを行うオーバーロードメソッドを追加しました。それを解決するよりエレガントな方法がある場合、私はすべての目ですlol gist.github.com/dasjestyr/90d8ef4dea179a6e08ddd85e0dacbc94
Sinaesthetic

2

私がこれとほぼ同じことをしたかったとき、私は反射を考慮して、それを難し​​い方法で実装しなければなりませんでした。が与えられたらT、を反省しtypeof(T)TryParseor Parseメソッドを探し、見つかった場合はそれを呼び出します。


これは私が提案しようとしていたことです。
Steven Evers

2

これは私の試みです。私はそれを「運動」としてやった。既存の " Convert.ToX() " -oneなどと同じように使用しようとしましたが、これは拡張メソッドです。

    public static bool TryParse<T>(this String str, out T parsedValue)
    {
        try
        {
            parsedValue = (T)Convert.ChangeType(str, typeof(T));
            return true;
        }

        catch { parsedValue = default(T); return false; }
    }

これと比較した場合の主な欠点はTypeConverter.ConvertFrom()ソースクラスが型変換を提供する必要があることです。これは、通常、カスタム型への変換をサポートできないことを意味します。
Ian Goldby 2017年

1

あなたが言ったように、TryParseはインターフェースの一部ではありません。また、基本クラスのメンバーでもありません。これは、実際staticstatic機能することはできませんvirtual。したがって、コンパイラーにはT実際にと呼ばれるメンバーがあることを保証する方法がないTryParseため、これは機能しません。

@Markが言ったように、独自のインターフェースを作成してカスタム型を使用することもできますが、組み込み型には運がありません。


1
public static class Primitive
{
    public static DateTime? TryParseExact(string text, string format, IFormatProvider formatProvider = null, DateTimeStyles? style = null)
    {
        DateTime result;
        if (DateTime.TryParseExact(text, format, formatProvider, style ?? DateTimeStyles.None, out result))
            return result;
        return null;
    }

    public static TResult? TryParse<TResult>(string text) where TResult : struct
    {
        TResult result;
        if (Delegates<TResult>.TryParse(text, out result))
            return result;
        return null;
    }

    public static bool TryParse<TResult>(string text, out TResult result) => Delegates<TResult>.TryParse(text, out result);

    public static class Delegates<TResult>
    {
        private delegate bool TryParseDelegate(string text, out TResult result);

        private static readonly TryParseDelegate _parser = (TryParseDelegate)Delegate.CreateDelegate(typeof(TryParseDelegate), typeof(TResult), "TryParse");

        public static bool TryParse(string text, out TResult result) => _parser(text, out result);
    }
}

0

これは「一般的な制約」の問題です。特定のインターフェースがないため、前の回答の提案に従わない限り、行き詰まります。

これに関するドキュメントについては、次のリンクを確認してください。

http://msdn.microsoft.com/en-us/library/ms379564(VS.80).aspx

これらの制約を使用する方法を示し、さらにいくつかの手がかりを与えるはずです。


0

http://blogs.msdn.com/b/davidebb/archive/2009/10/23/using-c-dynamic-to-call-static-members.aspxから借用

このリファレンスに従うとき:動的型を使用してC#4.0で静的メソッドを呼び出す方法

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

namespace Utils
{
   public class StaticMembersDynamicWrapper : DynamicObject
   {
      private Type _type;

      public StaticMembersDynamicWrapper(Type type) { _type = type; }

      // Handle static methods
      public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
      {
         var methods = _type
            .GetMethods(BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.Public)
            .Where(methodInfo => methodInfo.Name == binder.Name);

         var method = methods.FirstOrDefault();
         if (method != null)
         {
            result = method.Invoke(null, args);
            return true;
         }

         result = null;
         return false;
      }
   }

   public static class StaticMembersDynamicWrapperExtensions
   {
      static Dictionary<Type, DynamicObject> cache =
         new Dictionary<Type, DynamicObject>
         {
            {typeof(double), new StaticMembersDynamicWrapper(typeof(double))},
            {typeof(float), new StaticMembersDynamicWrapper(typeof(float))},
            {typeof(uint), new StaticMembersDynamicWrapper(typeof(uint))},
            {typeof(int), new StaticMembersDynamicWrapper(typeof(int))},
            {typeof(sbyte), new StaticMembersDynamicWrapper(typeof(sbyte))}
         };

      /// <summary>
      /// Allows access to static fields, properties, and methods, resolved at run-time.
      /// </summary>
      public static dynamic StaticMembers(this Type type)
      {
         DynamicObject retVal;
         if (!cache.TryGetValue(type, out retVal))
            return new StaticMembersDynamicWrapper(type);

         return retVal;
      }
   }
}

次のように使用します。

  public static T? ParseNumeric<T>(this string str, bool throws = true)
     where T : struct
  {
     var statics = typeof(T).StaticMembers();

     if (throws) return statics.Parse(str);

     T retval;
     if (!statics.TryParse(str, out retval)) return null;

     return retval;
  }

0

私はなんとかこのように機能するものを手に入れました

    var result = "44".TryParse<int>();

    Console.WriteLine( "type={0}, value={1}, valid={2}",        
    result.Value.GetType(), result.Value, result.IsValid );

これが私のコードです

 public static class TryParseGeneric
    {
        //extend int
        public static dynamic TryParse<T>( this string input )
        {    
            dynamic runner = new StaticMembersDynamicWrapper( typeof( T ) );

            T value;
            bool isValid = runner.TryParse( input, out value );
            return new { IsValid = isValid, Value = value };
        }
    }


    public class StaticMembersDynamicWrapper : DynamicObject
    {
        private readonly Type _type;
        public StaticMembersDynamicWrapper( Type type ) { _type = type; }

        // Handle static properties
        public override bool TryGetMember( GetMemberBinder binder, out object result )
        {
            PropertyInfo prop = _type.GetProperty( binder.Name, BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.Public );
            if ( prop == null )
            {
                result = null;
                return false;
            }

            result = prop.GetValue( null, null );
            return true;
        }

        // Handle static methods
        public override bool TryInvokeMember( InvokeMemberBinder binder, object [] args, out object result )
        {
            var methods = _type
            .GetMethods( BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.Public ).Where( methodInfo => methodInfo.Name == binder.Name );

            var method = methods.FirstOrDefault();

            if ( method == null )
            {
                result = null;

                return false;
            }

            result = method.Invoke( null, args );

            return true;
        }
    }

StaticMembersDynamicWrapperは、David Ebboの記事(AmbiguousMatchExceptionをスローしていました)を改変したものです。


0
public static T Get<T>(string val)
{ 
    return (T) TypeDescriptor.GetConverter(typeof (T)).ConvertFromInvariantString(val);
}

0

TypeDescriptorクラスの利用TryParseに関連する方法:

public static bool TryParse<T>(this string input, out T parsedValue)
{
    parsedValue = default(T);
    try
    {
        var converter = TypeDescriptor.GetConverter(typeof(T));
        parsedValue = (T)converter.ConvertFromString(input);
        return true;
    }
    catch (NotSupportedException)
    {
        return false;
    }
}

このコードは問題を解決する可能性がありますが、これが問題を解決する方法と理由の説明含めると、投稿の品質が向上し、投票数が増える可能性があります。あなたが今尋ねている人だけでなく、あなたが将来の読者のための質問に答えていることを忘れないでください。回答を編集して説明を追加し、適用される制限と前提を示してください。
ダブルビープ

0

上記の情報を使用して、これは私が開発したものです。オブジェクトを直接変換することも可能ですが、そうでない場合はオブジェクトを文字列に変換し、目的のオブジェクトタイプのTryParseメソッドを呼び出します。

メソッドのフェッチの負荷を軽減するために、メソッドが検出されるたびに、メソッドをディクショナリにキャッシュします。

オブジェクトをターゲットの型に直接変換できるかどうかをテストできます。これにより、文字列変換の部分がさらに削減されます。しかし、とりあえず省略します。

    /// <summary>
    /// Used to store TryParse converter methods
    /// </summary>
    private static readonly Dictionary<Type, MethodInfo> TypeConverters = new Dictionary<Type, MethodInfo>();

    /// <summary>
    /// Attempt to parse the input object to the output type
    /// </summary>
    /// <typeparam name="T">output type</typeparam>
    /// <param name="obj">input object</param>
    /// <param name="result">output result on success, default(T) on failure</param>
    /// <returns>Success</returns>
    public static bool TryParse<T>([CanBeNull] object obj, out T result)
    {
        result = default(T);

        try
        {
            switch (obj)
            {
                // don't waste time on null objects
                case null: return false;

                // if the object is already of type T, just return the value
                case T val:
                    result = val;
                    return true;
            }

            // convert the object into type T via string conversion
            var input = ((obj as string) ?? obj.ToString()).Trim();
            if (string.IsNullOrEmpty(input)) return false;

            var type = typeof (T);
            Debug.WriteLine($"Info: {nameof(TryParse)}<{type.Name}>({obj.GetType().Name}=\"{input}\")");

            if (! TypeConverters.TryGetValue(type, out var method))
            {
                // get the TryParse method for this type
                method = type.GetMethod("TryParse",
                    new[]
                    {
                        typeof (string),
                        Type.GetType($"{type.FullName}&")
                    });

                if (method is null)
                    Debug.WriteLine($"FAILED: Cannot get method for {type.Name}.TryParse()");

                // store it so we don't have to do this again
                TypeConverters.Add(type, method);
            }

            // have to keep a reference to parameters if you want to get the returned ref value
            var parameters = new object[] {input, null};
            if ((bool?) method?.Invoke(null, parameters) == true)
            {
                result = (T) parameters[1];
                return true;
            }                
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex);
        }

        return false;
    }

列挙をサポートするために別の関数を追加する必要がありました。列挙型の構文解析には「where T:struct」属性が必要と思われます。これを変換可能なものに機能させたいのです。(おそらく、型に変換可能な属性を追加する必要があります)。ただし、以下の提案のいくつかはよりシンプルに見えます(したがってより良いです)。
B Duffy

0

私はここにたくさんのアイデアをまとめ、非常に短い解決策に終わりました。

これは文字列の拡張メソッドです

enter code here

数値型のTryParseメソッドと同じフットプリントで作成しました

    /// <summary>
    /// string.TryParse()
    /// 
    /// This generic extension method will take a string
    ///     make sure it is not null or empty
    ///     make sure it represents some type of number e.g. "123" not "abc"
    ///     It then calls the appropriate converter for the type of T
    /// </summary>
    /// <typeparam name="T">The type of the desired retrunValue e.g. int, float, byte, decimal...</typeparam>
    /// <param name="targetText">The text to be converted</param>
    /// <param name="returnValue">a populated value of the type T or the default(T) value which is likely to be 0</param>
    /// <returns>true if the string was successfully parsed and converted otherwise false</returns>
    /// <example>
    /// float testValue = 0;
    ///  if ( "1234".TryParse<float>( out testValue ) )
    ///  {
    ///      doSomethingGood();
    ///  }
    ///  else
    ///  {
    ///      handleTheBadness();
    ///  }
    /// </example>
    public static bool TryParse<T>(this string targetText, out T returnValue )
    {
        bool returnStatus = false;

        returnValue = default(T);

        //
        // make sure the string is not null or empty and likely a number...
        // call whatever you like here or just leave it out - I would
        // at least make sure the string was not null or empty  
        //
        if ( ValidatedInputAnyWayYouLike(targetText) )
        {

            //
            // try to catch anything that blows up in the conversion process...
            //
            try
            {
                var type = typeof(T);
                var converter = TypeDescriptor.GetConverter(type);

                if (converter != null && converter.IsValid(targetText))
                {
                    returnValue = (T)converter.ConvertFromString(targetText);
                    returnStatus = true;
                }

            }
            catch
            {
                // just swallow the exception and return the default values for failure
            }

        }

        return (returnStatus);

    }

'' '


float testValue = 0; if( "1234" .TryParse <float>(out testValue)){doSomethingGood(); } else {handleTheBadness(); }
JDヒックス

0

T.TryParse ...なぜですか?

私はそのような一般的なTryParse機能を持っていることの利点を見ていません。異なるタイプ間でデータを解析および変換する方法が多すぎて、動作が競合する可能性があります。この関数は、コンテキストフリーの方法で選択する戦略をどのようにして知ることができますか?

  • 専用のTryParse関数を持つクラスを呼び出すことができます
  • 専用の解析関数を持つクラスは、try-catchおよびboolの結果でラップできます
  • 演算子のオーバーロードを含むクラスの場合、どのように解析を処理させますか?
  • 型記述子はを使用して組み込まれていConvert.ChangeTypeます。このAPIは実行時にカスタマイズ可能です。関数にデフォルトの動作が必要ですか、それともカスタマイズが可能ですか?
  • マッピングフレームワークがあなたのために構文解析を試みることを許可するべきですか?
  • 上記の競合をどのように処理しますか?

-2

XDocumentから子孫を取得するためのバージョン。

public static T Get<T>(XDocument xml, string descendant, T @default)
{
    try
    {
        var converter = TypeDescriptor.GetConverter(typeof (T));
        if (converter != null)
        {
            return (T) converter.ConvertFromString(xml.Descendants(descendant).Single().Value);
        }
        return @default;
    }
    catch
    {
        return @default;
    }
}
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.