Generic Method - Cannot implicitly convert type 'string' to T

May be a simple question..

I have an interface:

public interface ISanitizer
{
    T Sanitize<T>(T data_);
}

And an implementing class:

    public class BasicFilenameSanitizer : ISanitizer
    {

        private readonly String m_replacementCharacter = String.Empty;

        public BasicFilenameSanitizer(String replacementCharacter_)
        {
            if (replacementCharacter_ == null)
            {
                throw new ArgumentNullException("replacementCharacter_");
            }

            m_replacementCharacter = replacementCharacter_;
        }


        public virtual T Sanitize<T>(T filename_)
        {
            if (filename_ == null)
            {
                throw new ArgumentNullException("filename_");
            }

            Regex invalidCharacterRegex =
                new Regex(String.Format("[{0}]", Regex.Escape(new string(System.IO.Path.GetInvalidFileNameChar开发者_如何学Pythons()))));

//error occurs here
            return Regex.Replace(filename_.ToString(), invalidCharacterRegex.ToString(), m_replacementCharacter);
        }

}

In my particular case the following code generated the same error:

return (T) someData;

What helped me out - double cast with object:

E.g:

    static T MyFunction<T>() {
        string s = "test";

        if (typeof(T) == typeof(byte[]))
            return (T)(object)System.Text.Encoding.ASCII.GetBytes(s);
        else if (typeof(T) == typeof(string))
            return (T)(object)s;
        else throw new Exception();
    }

...

            var ba = MyFunction<byte[]>();
            var bs = MyFunction<string>();

In your code you are returning a string from a generic type which could be anything.

Change your code to this if you want a generic return type:

public interface ISanitizer<T>
{
    T Sanitize(T data_);
}

public class BasicFilenameSanitizer : ISanitizer<string>

If you simply want to always return a string you only need to change the method return type:

public interface ISanitizer
{
    string Sanitize<T>(T data_);
}

public virtual string Sanitize<T>(T filename_)

Your problem is that the method Sanitize<T> hasTas the return type, but the method actually returns astringfromRegex.Replace`.

Try changing the method to return a string instead:

public virtual string Sanitize<T>(T filename_)

That means you need to change your method in the interface to return string as well.

Adam,

your interface is incorrect, try:

public interface ISanitizer<T, TA>
{
    T Sanitize(TA data);
}

public class BasicFilenameSanitizer<T, TA> : ISanitizer<T, TA>
{
    public virtual T Sanitize(TA data)
    {
        throw new NotImplementedException();
    }
}

public class Test : BasicFilenameSanitizer<int, string>
{
    public override int Sanitize(string data)
    {
        return data.Length;
    }
    // a little test func...
    public void TestFunc()
    {
        int result = this.Sanitize("fred");
        Console.Write(result);
    }
}

[edited] - to add example.. cheers..

string result = "test";
return (T)Convert.ChangeType(result, typeof(T));