[C#] Detectie 32bit/64bit

[Zyphrax]

Gaat de applicatie draaien in 32bit of 64bit?
In VS2005 maak ik bijvoorbeeld een WinClient application. Ik zet in de Build options dat het platform target AnyCpu is (default). Ik compileer de WinClient op een 32bit machine. Ik draai de WinClient op een 64bit machine, vindt er dan emulatie plaats of draait de applicatie dan echt als een 64bit applicatie (in het kort: komt WOW64 in actie of niet?).

Hoe detecteer ik of ik onder 32bit Windows draai of 64bit?
Vanuit code zou ik graag zien of de tool onder 32bit Windows gedraait wordt or onder 64bit. De tool moet een paar systeembestanden aanpassen, dus dan moet ik in het ene geval de 32bit acties ondernemen en in het andere geval de 64bit acties. Heb ik hierbij dan ook last van WOW64?

Twee methoden die ik tegenkwam waren:
- De size bepalen van een IntPtr
- IsWow64Process API

Met beiden methoden kwam er niet uit waar ik op gehoopt had.
Heeft iemand hier een paar ijzersterke truuks/suggesties?

Alvast bedankt.

[RobLemmens]

als IntPtr.Size == 8 -> 64 bit machine,

edit: Sorry te snel geantwoord, dit wist je dus al.

.Net IL code wordt elke keer opnieuw gecompileerd bij het opstarten, je applicatie op een 64 bitter is dan ook 64 bits (de size van de intptr is dan ook 8 ), ook al heb je op een 32 bits machine de c# code gecompileerd naar IL.

[ Voor 95% gewijzigd door RobLemmens op 05-04-2007 14:29 ]

[roy-t]

(wil je niet tegen spreken maar was het niet zo dat de jit-compiler van .net alleen de eerste keer compileerd of bij verhuizing naar een nieuw systeem?)

[MTWZZ]

De jit compiler doet zijn werk bij de eerste keer dat een programma gestart wordt.
Dat houdt dus in dat wanneer je een programma op je eigen pc start de jitter aan de slag gaat. Kopieer je vervolgens de directory met het programma naar een andere pc dan gaat de jitter opnieuw aan de slag omdat het voor die pc de eerste keer is dat dat programma start.

[Zyphrax]

RobLemmens schreef op donderdag 05 april 2007 @ 14:24:
als IntPtr.Size == 8 -> 64 bit machine,

edit: Sorry te snel geantwoord, dit wist je dus al.

.Net IL code wordt elke keer opnieuw gecompileerd bij het opstarten, je applicatie op een 64 bitter is dan ook 64 bits (de size van de intptr is dan ook 8 ), ook al heb je op een 32 bits machine de c# code gecompileerd naar IL.

In de applicatie heb ik gebruikt:

code:

_isSystem64Bit = (IntPtr.Size != 4)

Dat lijkt alleen niet te werken.
Ik heb de .NET klasse opengesloopt met Reflector en zie ook bij IntPtr:

code:

public static int Size
{
    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
    get
    {
        return 4;
    }
}

Of is dat op een 64bit systeem anders? Andere .NET assemblies...

Nu zag ik iemand deze suggestie doen:

code:

public static bool Is64BitMode()
{
return System.Runtime.InteropServices.Marshal.SizeOf(type of(IntPtr))
== 8;
}

Iemand enig idee of dat werkt?
Ik heb helaas geen 64bit machine om de code te testen

[ Voor 3% gewijzigd door Zyphrax op 05-04-2007 15:59 ]

[voodooless]

Misschien even een vraagje langszij: Waarom heb je die detectie nodig? C# draait min of meer in een VM en is dus platformonafhankelijk. Je zou dus ook niet hoeven te weten op welke machine je draait...

[moto-moi]

Welke systeembestanden wil je dan wel aanpassen, want volgens mij zijn er gewoon calls om erachter te komen wat je system directory is, waardoor je niet naar dit soort dingen hoeft te kijken?

[beany]

edit: moto-moi was me te snel af

[ Voor 93% gewijzigd door beany op 05-04-2007 16:04 ]

[dotcode]

Je zal het aan het os moeten vragen of een stukje niet managed code schrijven om het te detecteren.
Volgens mij zijn de instellingen voor any-platform dat er niets wordt ge-prejit bij het compilen. Als je 32-bit insteld zal hij iets gaan prejitten.

[Snake]

Kijk of Program Files (x86) bestaat?

[moto-moi]

Snakiej schreef op donderdag 05 april 2007 @ 16:13:
Kijk of Program Files (x86) bestaat?

http://blogs.msdn.com/win...ve/2004/07/06/174568.aspx
Dat is dus ook geen oplossing

[Zyphrax]

dotcode schreef op donderdag 05 april 2007 @ 16:06:
Je zal het aan het os moeten vragen of een stukje niet managed code schrijven om het te detecteren.
Volgens mij zijn de instellingen voor any-platform dat er niets wordt ge-prejit bij het compilen. Als je 32-bit insteld zal hij iets gaan prejitten.

Ergo WOW64 vind dan ook niet plaats als je de applicatie draait onder 64bit?
Omdat de applicatie dan als een echte 64bit applicatie draait?

moto-moi schreef op donderdag 05 april 2007 @ 16:04:
Welke systeembestanden wil je dan wel aanpassen, want volgens mij zijn er gewoon calls om erachter te komen wat je system directory is, waardoor je niet naar dit soort dingen hoeft te kijken?

De functionaliteit is onderdeel van mijn applicatie VistaGlazz. Daarin patched de applicatie je systeembestanden, zodat je eigen styles kan gebruiken.

Ik wil expliciet weten of ik met 32bit of 64bit files aan het werken ben, want ik wil de hash van de systeem bestanden controleren voordat ik patch. Daarnaast zijn de DLLs inhoudelijk anders, waardoor ik ook niet exact dezelfde patch uit moet voeren.

[ Voor 46% gewijzigd door Zyphrax op 05-04-2007 17:39 ]

[moto-moi]

Als je een patch moet uitvoeren op bestanden waarvan je vooraf moet weten welke versie het is, dan klinkt het niet alsof je software gaat maken die nog jaren vooruit moet, maar eerder per SP aangepakt dient te worden?
In dat geval kun je toch eenvoudig zelf de hashes van alle benodigde dll's bepalen en deze in je code verwerken?

[Verwijderd]

moto-moi schreef op donderdag 05 april 2007 @ 17:59:
Als je een patch moet uitvoeren op bestanden waarvan je vooraf moet weten welke versie het is, dan klinkt het niet alsof je software gaat maken die nog jaren vooruit moet, maar eerder per SP aangepakt dient te worden?
In dat geval kun je toch eenvoudig zelf de hashes van alle benodigde dll's bepalen en deze in je code verwerken?

Dat lijkt me sowieso een strakker plan wegens de vele verschillende versies van de 3 DLL's die voor de uxtheme patch moeten worden aangepast. Daarmee overschrijf je ook niet per ongeluk DLL's met een andere taal bijvoorbeeld.

[Confusion]

Als er high level functies zijn waarmee je de CPU flags kan uitlezen -> alleen x86_64 CPU's hebben een 'lm' flag.

[Zyphrax]

moto-moi schreef op donderdag 05 april 2007 @ 17:59:
Als je een patch moet uitvoeren op bestanden waarvan je vooraf moet weten welke versie het is, dan klinkt het niet alsof je software gaat maken die nog jaren vooruit moet, maar eerder per SP aangepakt dient te worden?
In dat geval kun je toch eenvoudig zelf de hashes van alle benodigde dll's bepalen en deze in je code verwerken?

De hashes van de dll's heb ik nu ook in code verwerkt.

De code checkt of de hashes overeenkomen met de hashes die verwacht worden (en bepaalt daar het verschil tussen original/patched/corrupt). Ik zou graag van te voren willen weten aan de hand vh systeem, welke systeem file daar hoort. Zodat ik bij corrupt de optie kan bieden "Patch anyway".

Bedankt voor jullie hulp trouwens

[Zyphrax]

Zo te zien had ik eerder een fout gemaakt.
Onderstaande lijkt te werken:

code:

bool is64Bit = (IntPtr.Size == 8);

[ Voor 3% gewijzigd door Zyphrax op 05-04-2007 20:51 ]

[alienfruit]

Je kan ook kijken of de Windows DLLs x64 zijn of niet