I'm currently implementing the seperate forward pass after the opaque geometry (deferred) for rendering transparent alpha blended geometry.Though I feel like I'm still lacking a bit of understanding how to accomplish this.

You need to re-use your depth buffer from deferred shading. This means that when doing your forward pass you must render to a target consisting of your composed color and your original G-buffer's depth buffer. This way your forward-lit geometry ends up in the composed image, and will properly interact with your opaque geometry in terms of depth.

Hmm both are being rendered to the back buffer at the moment. I just tried it without clearing the depth buffer, oddly enough it still gives me the same result. Do I not have to set the Depth off or at least read only when doing the transparent geometry ?

Is Depth Write on during your lighting or compose steps? If so, that could be your problem. You should not be writing to the depth buffer during either of them, nor should you be testing against the depth buffer in your composition step.

Assuming your camera transforms are the same for your forward and G-Buffer phases, and you haven't destroyed the depth buffer by enabling depth write for any step after creating your G-buffer, enabling depth test for your transparent draw step should "just work."

I got it exactly like you said now still the same.
The problem here I think is that XNA discards the depth buffer after switching the rendertarget.
Problem though is when telling it to preserve contents my GBuffer pass doesn't output anything.
(PIX debugging tells me "This pixel was eliminated because: It failed the depth test")

As I see it my only workarounds here are either:

- Drawing Z only geometry again

or

- Outputting Depth from my DepthBuffer (written out in the gbuffer pass)

as of 4.0, when using multiple render targets, XNA associates the depth buffer with the render target bound to index 0. (I assume you've got a couple, to represent color/depth/normal).

This is just a guess, but I think you can reuse your depth values by doing the following:

1. Pick a render target you DON'T need for image composition. Set it to preserve contents (or I guess you could bind a "dummy" texture that you won't sample here);
2. Bind this render target to index 0, put your color, specular power, whatever other targets you render to on higher indices.
3. Clear color and depth.
4. Do your G-buffer pass.
5. Disable depth writing
5. Unbind your render targets for now.
6. Do your light pass.
7. Disable depth testing, and rebind the render target you had on index 0 for the G-Buffer pass (once again to index 0)
8. Bind the render target for your final deferred shading output to index 1 (or whichever index you choose that is > 0)
9. Do the image composition pass, writing the final color into the render target on index 1.
10. re-enable depth testing. (Writing should stay OFF if you want consistency in the appearance of your translucent objects)
11. Draw your transparent geometry, outputting the lit color value to index 1
12. Disable depth testing again
13. Bind the render target from index 1 as a texture, and copy it to the backbuffer via a full screen draw. This also gives you an opportunity to post-process your rendered image however you see fit.

..Long list, but I think it'd do the trick.

..Alternatively you could write a light prepass renderer, where your "image composition" pass involves re-drawing your opaque geometry anyway, and just associate the correct depths with your composition render target automatically. The only way to know which would be more efficient in XNA would be to try both (or see if somebody has).

Alright so I've done it until part 11. and checking the rendertarget but what I get is only the opaque cube not the transparent one. It only appears again if I enable depth write. But when that happens I get the same old result.