Value of Type 'T' Cannot Be Converted To

Value of type 'T' cannot be converted to

Even though it's inside of an if block, the compiler doesn't know that T is string.

Therefore, it doesn't let you cast. (For the same reason that you cannot cast DateTime to string)

You need to cast to object, (which any T can cast to), and from there to string (since object can be cast to string).

For example:

T newT1 = (T)(object)"some text";
string newT2 = (string)(object)t;

Java incompatible type: T cannot be converted to My Class

T will be a type that is defined in the overloaded DataChecker.compare() method.

That is almost entirely useless. In java, overloads are completely different methods that have absolutely no relationship whatsoever; code is interpreted at compile (write) time to one of the overloads, and that particular method is then hardcoded in your class file. At runtime, override is applied dynamically (java is fully dynamically dispatched), but the 'full name' of each method includes the complete type it is, the name, and the types of each parameter, and the return type.

In other words, it is not possible to tell the compiler: Just figure it out; call the right compare method, and I guarantee you it will be there. I guess, if not, throw a ClassCastException or something.

If you think about it for a while, this starts to make some sense. String is a subtype of Object, but also of CharSequence, and also of Serializable. Imagine you had compare(Serializable a, Serializable b) as well as compare(CharSequence a, CharSequence b). Which one should be called?

The only solution, then, is to either have no overloads, or to create a single method that is the entrypoint for this dynamic process, which does its own, handrolled dynamic dispatch, based on e.g. a Map<Class<?>, BiPredicate<?>> or a bunch of instanceof checks.

Generic Func: Key path value type '[T]' cannot be converted

Since the URL gives you an array of Ts, you should decode an array, rather than a single T in the decode call. This line

.decode(type: T.self, decoder: JSONDecoder())

should be:

.decode(type: [T].self, decoder: JSONDecoder())

That replaceError call is going to crash your app, as T.self is not a T (it's a T.Type), and you are force-casting. Since you are receiving an array, a logical choice for a value to replace errors with, is the empty array []:

.replaceError(with: [])

Also, remove your generic parameter on init:

init() {

Swift generics error: Cannot convert value of type 'Type T ' to expected argument type 'Type _ '

You are using a non-generic concrete type MyModel in a generic function, that doesn't work.

You could do something like this

class Test {
    func test<T: MyProcotol>(item: T, completion: (Result<T>) -> Void) {
        let result : Result<T> = .success(value: item)
        completion(result)
    }
}

C# casting error on generics

Cannot convert type 'T' to 'float' indicates that the compiler simply doesn't know exactly what kind of data type that generic type parameter T currently has. Any attempt to cast T to other type except for object (as base class of all objects) will result InvalidCastException.

Hence, based from how generic type parameter works as explained above, the code can be written as this:

unsafe private void PerformWindowLevel<T>(int lower, int upper, ref T[] pixels)
{
    float shift = 3.0F; // some value
    float scale = 5.0F; // some value
    float val = (Convert.ToSingle((object)pixels[i]) + shift) * scale;
}

or include a check for byte data type before performing cast:

unsafe private void PerformWindowLevel<T>(int lower, int upper, ref T[] pixels)
{
    if (typeof(T) == typeof(byte))
    {
        float shift = 3.0F; // some value
        float scale = 5.0F; // some value
        float val = (Convert.ToSingle((object)pixels[i]) + shift) * scale;
    }
}

Note that the generic itself should be completely independent of the type, so if type parameter T intended to just accept byte just use ref byte[] pixels instead.

NB: About the message A type used as a constraint must be an interface, a non-sealed class or a type parameter, it can be explained where float (System.Single) itself is just a struct, which is implicitly sealed. A struct or sealed class can't be used as generic type parameter constraint, but you can constrain that T is a struct. Currently valid constraints should be like this:

void GenericMethod<T>() where T: class // reference type constraint

void GenericMethod<T>() where T: struct {} // value type constraint

void GenericMethod<T>() where T: new() // public parameterless constructor constraint

void GenericMethod<T>() where T: IConvertible // interface constraint

void GenericMethod<T>() where T: BaseClass // base class constraint

More info: Constraints on Type Parameters

Similar issues:

Cannot implicitly convert type 'T' to 'Int'

Value of type 'T' cannot be converted to

Cannot convert value of type 'T?' to expected argument type 'T?'

You need to use an associatedtype in your protocol so all functions/variables in the protocol uses the same type because otherwise each function with a <T> will be using a different type

Example (simplified

protocol PostDataProviderProtocol{
    associatedtype T

    func getItemAt(index:Int)-> T?
    func replaceItemAt(index:Int, item:T?)
}

Then in your class you can use it as

class BaseDataProvider<SomeType> {
    internal var _itemsPerPage:Int = 0
    internal var _page:Int = 0
    internal var _endpoint:String = ""
    internal var cachedData:[SomeType?] = []
}

extension BaseDataProvider: PostDataProviderProtocol {
    typealias T = SomeType

    func hasNext() -> Bool {
        true
    }

    func getItemAt(index: Int) -> T? {
        self.cachedData[index]
    }

    func getItems() -> [T] {
      return self.cachedData as! [T]
    }

 }

Value of 'String' cannot be converted to Type 'T'. Generic function for getting query strings?

The safest way is to use CTypeDynamic. This will ensure that implicit/explicit operators are used.

Function Convert(Of T)(s As String) As T
    Return Microsoft.VisualBasic.CTypeDynamic(Of T)(s)
End Function

This will work for simple types but will fail for complex ones.

Function Convert(Of T)(s As String) As T
    Return CType(CObj(s), T)
End Function

Cannot implicitly convert type 'T' to 'Int'

you can try casting the value like this ...

t += (int)value; 

or

t+= Convert.ToInt32(value);

Cannot convert type 'T' to bool

Unfortunately the rules for generic conversions in C# don't allow for this directly, but you can go via object. For example:

byte[] data = (byte[]) (object) value;

However, you might consider whether it's really appropriate for this to be a generic method anyway... it's not like it copes with all types, or does exactly the same thing for all of the types that it does accept.

I'd also strongly recommend extracting the expression ((XDevkit.IXboxConsole) this.XboxConsole) which is used in all the success cases.

---

Related Topics