(C#) why does Visual Studio say it's an object while GetType says it's a Func<object>?
C# newbie question here. The following code (taken from the book \"C# From Novice to Professional\" by Christian Gross, Apress) gives an error:
worksheet.Ad
-
Others have given accurate and detailed answers, but here I will try to explain in simple language.
When you write
worksheet["A2"]you really are calling a member function ofworksheetworksheethas a member function named[]that accepts astringand returns anobjectThe signature of the member function
[]looks likeobject this[string id]So the function
worksheet["A2"]returns something that is anobject. It could be anintor astringor many other things. All the compiler knows is that it will be anobject.In the example, you have it returning a
Func. This is fine, becauseFuncis anobject. However, you then pass the result of that function in as a parameter to another function.The problem here is that the compiler only knows that
worksheet["A2"]returns anobject. That is as specific as the compiler can be. So the compiler sees thatworksheet["A2"]is an object, and you are trying to pass the object to a function that does not acceptobjectas a parameter.So here you have to tell the compiler "hey dummy, that's a
Func" by casting the returned object to the correct type.worksheet.Add("C3", CellFactories.DoAdd(worksheet["A2"], worksheet["B1"]));can be re-written as
worksheet.Add("C3", CellFactories.DoAdd((FuncNow the compiler knows that, even though the
[]function returns anobject, it can treat it like aFunc.side note: You're probably doing too much on one line. That may be hard for people to read in the future.
Why does the called method 'see' the argument as a different type than the GetType() returns?
The compiler only knows that
worksheet[]returns an object. The compiler can not callGetType()on it at compile time.What good is the GetType() method?
There are quite a few uses and abuses of the
GetType()method, but that is an entirely different discussion. ;)In summary, the compiler does not assume anything about types. This is a good thing because you get a compile time error when you try to fit this square peg into a round hole. If the compiler did not complain, this error would surface at run-time, which means you would probably need a unit test to detect the problem.
You can get around this problem by telling the compiler "I know for a fact that this thing is a round peg, trust me." and then it will compile. If you lie to the compiler, you will get a run-time error when that code is executed.
This is called "static typing". The opposing philosophy is called "dynamic typing" where type checks are done at run-time. Static vs dynamic is a lengthy debate and you should probably research it on your own if you're interested.
加载中...
- 热议问题