C# Discussion Boards - CodeProject

12-Mar-04 5:18

See the Microsoft Patterns and Practices[^] section. They have books available for download as PDFs (you can also buy them as books, but the PDFs are complete). One or two go into depth with instrumenting your application, like the Enterprise Instrumention block.

As far as trace listeners, the documentation for the TraceListener in the .NET Framework SDK should be sufficient. There isn't much you can do with these, though, which is where the EI comes into play.

Microsoft MVP, Visual C#
My Articles

Strange Behaviour

Matthew Hazlett12-Mar-04 4:42

Matthew Hazlett

12-Mar-04 4:42

I have my multi-threaded plugin app that I wrote. In the dispose method of a plugin if I issue a Application.Exit it exits both the plugin and the parent app.

Is this normal, seems kinda strange to me...

Matthew Hazlett
Windows 2000/2003 MCSE
Never got an MCSD, go figure...

Re: Strange Behaviour

Heath Stewart12-Mar-04 4:53

Marshaling Array of IntPtr

12-Mar-04 4:53

Um, this is what it's supposed to do. That's why it's Application.Exit. Read the documentation.

Besides, you don't need to exit anything when your plugin is disposed. The reference object is freed. You really don't even need to implement IDisposable unless you have native resources or other resources you want cleaned up. This is how a garbage collection platform - like .NET and Java - work.

Microsoft MVP, Visual C#
My Articles

Tristan Rhodes12-Mar-04 3:30

12-Mar-04 3:30

Hi folks

I've got an array that i am using as a refference to COM that will store the IntPtr's returned from the IEnumID.

<br />
		[PreserveSig]<br />
		int Next(<br />
			/* [In] */int celt,							//Number of items in submitted array<br />
			[MarshalAs(UnmanagedType.LPArray, SizeConst = 100)]<br />
			/* [In, Out] */IntPtr[] rgelt,				//Address of Array<br />
			/* [Out] */out int pceltFetched);			//Address of Item Count<br />

While i have it marshaling as an LPArray, the problem i face is that the pointer points to the first element (as far as I can see), and while, forwarding this array to the Next produces a new result (Assumably the next folder in the enumeration), it is only ever allocated to the first possition. The values for the celt increments properly, but the pCeltFetched is always equal to 1 after the first method call.

Am I marshaling it incorectly? I've tried using SafeArray with an IntPtr type, but the compiler keeps spitting it out.

I know that they are marshaled as in only by default, but is there some special handling procedure for selecting the index that the array should begin at?

I have also tried converting the array to a unmanaged structure, so that i can simply use a pointer to handle it, instead of marshaling to and from managed code with each call. However, i get null pointer exceptions, and it's not liking it. I'm calling like this:

IntPtr[] EnumerationArray = new IntPtr[100];<br />
IntPtr ArrayHandle = IntPtr.Zero;<br />
Marshal.StructureToPtr(EnumerationArray, ArrayHandle,true);

Cheers

Cata

John Fisher12-Mar-04 3:46

John Fisher

12-Mar-04 3:46

Hi, I don't know the answer to your question, but this 10 minute MSDN video[^] could very well provide the information you need to solve the problem yourself. It discusses the different ways that items are marshalled in platform invoke calls, though not specifically about COM.

BTW, assuming I knew the answer to your problem, it would be difficult to answer your question without also knowing what the COM interface actually expects. You've only listed the part that isn't using the interface correctly. [edit]I might have assumed incorrectly there, if you are referring to the common enumeration interfaces that COM defines.[/edit]

John

"You said a whole sentence with no words in it, and I understood you!" -- my wife as she cries about slowly becoming a geek.

- COM Interface Function

Tristan Rhodes12-Mar-04 3:51

12-Mar-04 3:51

This is how it is written in C:

HRESULT Next(
ULONG celt,
LPITEMIDLIST *rgelt,
ULONG *pceltFetched
);

where celt is the number of items in the array that is forwarded.
rgelt is a pointer to the array.
pceltFetched is a pointer to a value that holds the number of elements in the returned array.

I shall check this video out.

Cheers

Cata

Heath Stewart12-Mar-04 4:07

12-Mar-04 4:07

That's the way it's supposed to work. Read the documentation in the Platform SDK for IEnumXXXX. It's just like an IEnumerator in .NET, only COM's IEnumXXXX implementations can fetch multiple results depending on what you pass into celt (the first param to Next). If you know the size of the object (like an ITEMIDLIST, which you can get with Marshal.SizeOf), you can get the offset the address and get the next object in the array using other methods in the Marshal class, or using an unsafe context.

Another way would be to create an array of ITEMIDLIST (or whatever struct you need, so long as it's defined and attributed properly) and pin the object to gets its address like so:

ITEMIDLIST[] items = new ITEMIDLIST[40];
GCHandle handle = GCHandle.Alloc(items);
int len;
iEnum.Next(items.Length, handle.AddrOfPinnedObject(), out len);
handle.Free();

Then you should be able to access the elements of the array with managed code.

Microsoft MVP, Visual C#
My Articles

Tristan Rhodes12-Mar-04 4:23

12-Mar-04 4:23

Hmmmm.

Maybe i've misinterpreted what i read.

I was under the assumption that the array that i hand to the Next object, is something akin to a stack that new PIDL's are added too, and the celt is the number of items currently on the array, or the index at which the next PIDL is added.

Seems kind of dumb now i think about it.

The PIDL that i am getting back in the first part of the array (I only get one PIDL at a time), is the one i'm looking for?

Can i continuously increment next, and store the PIDL in a purely managed array?

Cheers

Cata

Heath Stewart12-Mar-04 4:28

12-Mar-04 4:28

The Catalyst wrote:
Can i continuously increment next, and store the PIDL in a purely managed array?

Sure. Why not? You should use a list, though, since you'd have to resize the array yourself, or use any length property that the enum might have.

The Catalyst wrote:
I was under the assumption that the array that i hand to the Next object, is something akin to a stack that new PIDL's are added too, and the celt is the number of items currently on the array, or the index at which the next PIDL is added.

Nope. The first param is how large the array is. Since an array is just a pointer, you have to tell native APIs how many elements are in that array so it can use offsets to fill the addresses. This is true of any native API that uses arrays (even character arrays like LPTSTR).

Microsoft MVP, Visual C#
My Articles

Tristan Rhodes12-Mar-04 4:45

12-Mar-04 4:45

Thanks Heath, most helpful. I was planning on using an arraylist. Smile | :)

One more question.

I'm running my call through Next, like this:

			//Declare enumeration Variables<br />
			IntPtr[] EnumerationArray = new IntPtr[10];<br />
			int ArrayLengthIn = 10;<br />
			int ArrayLengthOut = 0;<br />
<br />
			//Enumerate Objects<br />
			ContentEnumeration.Next(ArrayLengthIn,EnumerationArray,out ArrayLengthOut);

But I only ever get a single value returned.

I'm not sure why this is, as i know that there is more than 1 folder on my C drive. I'll have a play with one of the pointers i get back from the array, but can you see any reason why it's only returning a single value?

Cata

Heath Stewart12-Mar-04 4:50

12-Mar-04 4:50

COM requires the address of the first element of an array. IntPtr is the managed representation of that address. The COM implementation doesn't care about arrays, only that address, so declaring the method to accept an array and passing an array in does not matter - it's only going to assign the address of the first array element in its implementation. You need to offset that address to get additional elements, which the Marshal class (or unsafe code) can help with.

Microsoft MVP, Visual C#
My Articles

Tristan Rhodes12-Mar-04 5:24

12-Mar-04 5:24

AWESOME! Thanks DUDE!

I got it enumerating properly.. well... i got a sub folder name without it crashing, exploding, or whatever. I'll worry about getting multiple PIDL's later.

One thing is confusing me though.

My StrRetToStr, while working, does odd stuff. 0 seems to be the value that works, but in COM it's supposed to be 1-3. Is this because i'm using signed ints?

Also, my StrRetToStr method refuses to work with a string base type, no matter how I marshal it. But if i change it to a pointer, process it, and change it back, it works fine. I know it's trivial, but i don't understand why it's doin it, and it's bugging me.

Again, thanks for all your help. While i know i've got a long way to go, it's another step towards me grasping COM more completely. *grin*

Cheers!

Cata

Heath Stewart12-Mar-04 5:29

12-Mar-04 5:29

The Catalyst wrote:
While i know i've got a long way to go, it's another step towards me grasping COM more completely.

You REALLY need to learn COM first. Thinking you'll learn COM through .NET Interop is really a naive assumption. Learn COM first - it's difficult enough. You clearly don't understand as much about marshaling as you should. Write a few COM applications first and pick up a good book on COM. You need to know both .NET and COM appart from each other before interop'ing the two. That's pretty much a universal truth.

Microsoft MVP, Visual C#
My Articles

Tristan Rhodes12-Mar-04 6:28

12-Mar-04 6:28

I've been playing with the GCHandle class, and trying to get a full array, but still not having any joy with it. The array still contains only one entry when it is returned.

			//Declare enumeration Variables<br />
			IntPtr[] EnumerationArray = new IntPtr[10];<br />
			//Garbage Collection Handle<br />
			GCHandle handle = GCHandle.Alloc(EnumerationArray, GCHandleType.Pinned);<br />
<br />
			//Declare ArrayStats<br />
			int ArrayLengthOut;<br />
<br />
			//Enumerate Objects<br />
			ContentEnumeration.Next(EnumerationArray.Length,handle.AddrOfPinnedObject(),out ArrayLengthOut);<br />
<br />
			//Unallocate Handle<br />
			handle.Free();<br />
<br />
			//Fetch IntPtr from array<br />
			IntPtr pTest = EnumerationArray[0];

Where can i look for information on manualy offsetting arrays? I understand how it's done in structs.

Cata

webservice

cmarmr12-Mar-04 3:26

cmarmr

12-Mar-04 3:26

ok i have a webservice written in foxpro and it accesses a database and passes me back information from the database how do i call this webservice
i added ref. to the webservice how do i use it can somebody give me an example
(the foxpro service generated a test.wsdl file this is the file i am adding ref. to)

thanks
chad

Re: webservice

Heath Stewart12-Mar-04 4:09