|
Hello,
I have an annoying issue where I could use some advice.
I created a small windows service which uses at standard time-intervals different COM components.
Every time the COM components are instantiated in their own thread, the required methods are invoked and the COM components are subsequently released and their threads end, the main thread can then evaluate the result of each COM component's action.
For some COM components(third party) a problem occurs from time to time and the instantiation of the COM object blocks the thread. Even calling an Abort on these threads is not possible because doing that causes the main-thread to block.
The COM components are simply instantiated using:
<br />
System.Activator.CreateInstance(comType);
The comType is gotten using:
<br />
Type comType = Type.GetTypeFromProgID(sComName);
If this blocking happens frequently, the memory of the process increases steadily due to all the blocked threads that I can't stop.
So what I need is an ability to use the COM components, and still be able to clean up the threads in case such a block occurs. Does anyone have any ideas how I could accomplish that?
Regards,
Davy
|
|
|
|
|
GDavy wrote: Does anyone have any ideas how I could accomplish that?
An ugly workaround, but you could consider putting them in a separate app and using IPC to communicate with the COM-component. Once the app seems to hang, you kill it 
I are Troll 
|
|
|
|
|
After much painfull and brain numbing reading I still don't understand why its not possible to cast between Action<T> and Action<object>, can anyone please explain this in small words (I currently have the brain of a 5 year old).
There was a poem written along time ago by a person dying with lots of pain, he called it 'Brother Pain', I'm about to write a poem called 'Brother Cannot implicitly convert type 'System.Action<T>' to 'System.Action<object>''
An example:
public class Base
{
public Func<object> OnComplete {get;set;}
public Base(Func<object> onComplete)
{
OnComplete = onComplete;
}
}
public class GenericBase<T> : Base
{
public GenericBase(Func<T> onComplete) : base(onComplete)
{
OnComplete = onComplete;
}
}
____________________________________________________________
Be brave little warrior, be VERY brave
modified on Thursday, March 31, 2011 3:22 AM
|
|
|
|
|
It says 'implicitly', so have you tried an explicit cast?
public class GenericBase<T> : Base
{
public GenericBase(Func<T> onComplete) : base((Func<object>)onComplete)
{
OnComplete = (Func<object>)onComplete;
}
}
|
|
|
|
|
Did it build on your side? On my side I get 'Cannot convert type 'System.Func<T>' to 'System.Func<object>''
At least now my build error message is different
____________________________________________________________
Be brave little warrior, be VERY brave
|
|
|
|
|
Adriaan Davel wrote: After much painfull and brain numbing reading I still don't understand why its not possible to cast between Action<T> and Action<object>,
Because T might be an integer, and that's not compatible with object.
I are Troll
|
|
|
|
|
Not sure I understand what you mean, this object x = 1; works...
____________________________________________________________
Be brave little warrior, be VERY brave
|
|
|
|
|
Your example would still be an object, allocated on the heap. To use x as an integer would still need to be converted (int)x = ?
|
|
|
|
|
Adriaan Davel wrote: this object x = 1; works
That wraps your value-type with a reference-type; your number is actually stored in the object, but a number is not an object itself.
I are Troll
|
|
|
|
|
Ok, but in non-generic syntax this works:
private void Button_Click(object sender, RoutedEventArgs e)
{
Calc(1);
}
private void Calc(object val)
{
}
but in generic syntax it doesn't?
____________________________________________________________
Be brave little warrior, be VERY brave
|
|
|
|
|
"Shouldn't"; there's a difference between simple types (anything that's a value) and classes, that's why there's a "where T:class" constraint
I are Troll
|
|
|
|
|
I know that, and object allows me to pass either and respond accordingly inside the method to which I passed the parameter
____________________________________________________________
Be brave little warrior, be VERY brave
|
|
|
|
|
..because you can check what type of object that it is. That's what VS does at compile-time, and since an integer isn't an object it gives an error. It could be wrapped in an object, that's true - but if that's what should be done, then it has to be explicit. Remember that you can't inherit from an integer, so it does make sense to differentiate between the parameter-behaviour and the generics' behaviour
I are Troll
|
|
|
|
|
In .net, everything is an object. 
|
|
|
|
|
That's one of those generalizations that I loathe. Yes, structs are objects too.
..but that doesn't make 'em interchangeable
I are Troll
|
|
|
|
|
Eddy Vluggen wrote: but that doesn't make 'em interchangeable
Yes it does, assuming the container being used to intercahnge them types the variable as object.
|
|
|
|
|
J4amieC wrote: Yes it does, assuming the container being used to intercahnge them types the variable as object.
The keyword here is "assuming", and your assumption is a leaky abstraction
Reference-types are objects, value-types can be boxed in an reference-type. And no, a namespace isn't an object, it's not even a type.
Once you state that everything is an object, people will assume that anything can be used as a base to derive from (since OO is partly about inheriting from existing objects).
I are Troll
|
|
|
|
|
Eddy Vluggen wrote: Once you state that everything is an object, people will assume that anything can be used as a base to derive from
Any non-sealed Type can be used as a base to derive from. What's your point?
|
|
|
|
|
J4amieC wrote: Any non-sealed Type can be used as a base to derive from.
You can circumvent the impossibility of inheriting a structure by pointing out that it's a sealed class - but that doesn't change the validity of my statement. I took the example of a namespace to prevent the hairsplitting discussion that structs are merely mutilated classes under the hood
J4amieC wrote: What's your point?
That the text "everything is an object" is incorrect. I stated that literally, didn't I? 
I are Troll
|
|
|
|
|
(Whoops, sorry to have started that.  )
|
|
|
|
|
The reason you can't do it is fairly simple. Action<T> is generic - fair enough, and you want it to be Action<object> - ok? Simplistically you would think this would work because no matter what type T was, it would ultimately be convertable to object, as everything derives from object.
Suppose though, that type T was a string, and you wanted to use Action<int> - all of a sudden, there's a conversion that is not implicitly possible - in other words, you would have to perform an explicit cast. The cast into object would have to be a special case in the compiler, so they chose not to do this - instead, like for like typing is the only way to achieve this.
|
|
|
|
|
Thanks for the reply Pete, just not sure I fully understand your explanation.
What you are saying that (assuming this was allowed) this wouldn't be a problem:
Action<object> act = null;
act = new Action<int>();
but the problem would come in if I tried:
act("a");
If that's what you are saying then I'm a bit disappointed in MS because type conversion from object has always posed this challenge (I recon this is why generics was brought in) and yes its fair to expect me to pass the right value in or get a runtime error...
____________________________________________________________
Be brave little warrior, be VERY brave
|
|
|
|
|
That's exactly what I'm saying. The thing is though, generics were brought in for things like type safety and to prevent aid the developer move away from boxing/unboxing. By having object as the generic type, you've just gone back to having a boxing/unboxing issue - and you're no better off than just passing Action across rather than the generic Action.
|
|
|
|
|
I understand that I should avoid boxing & un-boxing (and I do want to, and I do it everywhere), in this case it's not an option. Bit of a complex scenario I'll have to explain (and the code is part of a 5 000 file solution), but I'm quite irritated that this is disallowed, I thought polymorphism / covariance / contravariance is exactly about this...
____________________________________________________________
Be brave little warrior, be VERY brave
|
|
|
|
|
It is, for objects - aka reference-types, not for value-types. C# is really strict on the difference.
The posted alternative with the interface does look like it (could) solve your problem. Alternatively, you could decide only to pass objects, and to wrap your ints in a MyInt class.
I are Troll
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
