DETECTAR SISTEMA OPERACIONAL

PLUGSOFTSM 13/06/2016 11:10:50
#463435
Pessoal...
Gostaria de uma ajuda muito preciosa...

Meu sistema permite a impressão de etiquetas usando a argox. Uso a dl Winppla e funciona tudo OK. O que acontece é o seguinte: Existe uma dll para 32 bits e outra para 64 bits e, eu preciso que na seção de declarações o Sistema identifique o ambiente se 32 ou 64 bits e leia as informações do arquivo cert, pois criei duas pasta, uma win32 e outra win64 e dentro delas gravei as dll[ô]s de acordo com a plataforma
Tentei fazer assim, mas não funcionou:

ReadOnly X As String = Environment.GetEnvironmentVariable([Ô]PROCESSOR_ARCHITECTURE[Ô], EnvironmentVariableTarget.Machine)

#If X = [Ô]AMD64[Ô] Then [ô]64 Bits
<DllImport([Ô]\Win64\WINPPLA.DLL[Ô])> Friend Function A_GetUSBBufferLen() As Integer

End Function
<DllImport([Ô]\Win64\WINPPLA.DLL[Ô])> Friend Function A_EnumUSB(ByVal buf As Byte()) As Integer

End Function
#Else
<DllImport([Ô]\Win32\WINPPLA.DLL[Ô])> Friend Function A_GetUSBBufferLen() As Integer

End Function
<DllImport([Ô]\Win32\WINPPLA.DLL[Ô])> Friend Function A_EnumUSB(ByVal buf As Byte()) As Integer

End Function
#EndIF

Alguma dica?
KURTGU 13/06/2016 11:40:00
#463437
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
MsgBox(GetOSArchitecture())
End Sub


Public Function GetOSArchitecture() As String



Dim osClass As System.Management.ManagementClass = Nothing
Dim result As String = [Ô]32-bit[Ô] [ô] Default to 32-bit for OSes which don[ô]t support the OSArchitecture property of the Win32_OperatingSystem WMI class.

Try

[ô] Get the singleton Win32_OperatingSystem WMI class so we can access properties about the OS.
osClass = New System.Management.ManagementClass([Ô]Win32_OperatingSystem[Ô])

[ô] Loop thru all properties of the single instance of the Win32_OperatingSystem class and look for the property which will tell us if
[ô] the OS is 32-bit or 64-bit. If the property is not found, the OS is assumed to be 32-bit.
[ô] NOTE: I[ô]m not 100% sure if this detects 64-bit versions of XP. See above MSDN link for more information.
For Each mgo As System.Management.ManagementObject In osClass.GetInstances
For Each prop As System.Management.PropertyData In mgo.Properties
If prop.Name = [Ô]OSArchitecture[Ô] Then
result = prop.Value.ToString
Exit For
End If
Next
Next

Catch ex As Exception

result = String.Empty

Finally

[ô] Clean up
If osClass IsNot Nothing Then osClass.Dispose()

End Try

Return result

End Function
PLUGSOFTSM 13/06/2016 11:56:05
#463438
Meu problema não está em detectar o sistema operacional e sim em fazer com que o #If ... #Else.... #Endif seja reconhecido, pois somente um fica ativo o outro bloco fica, parece desabilitado e, eu quero ter acesso aos dois
KURTGU 13/06/2016 12:56:03
#463441
Entendi...
OCELOT 13/06/2016 14:40:32
#463442 Resposta escolhida
Neste caso você não pode usar o #IF, #ELSE, #ENDIF, eles são para compilação condicional, ou seja, este IF é resolvido durante a compilação e parte do código pode ser incluída ou excluída do programa, isso é útil quando se precisa criar dois executáveis diferentes usando o mesmo código com pequenas diferenças.

No caso se está compilando seu programa para AnyCPU então eu diria para fazer assim
Imports System.Runtime.InteropServices

Module MinhasFuncoes

    <DllImport([Ô]\Win64\WINPPLA.DLL[Ô], EntryPoint:=[Ô]A_GetUSBBufferLen[Ô])>
    Private Function A_GetUSBBufferLen64() As Integer
    End Function
    <DllImport([Ô]\Win64\WINPPLA.DLL[Ô], EntryPoint:=[Ô]A_EnumUSB[Ô])>
    Private Function A_EnumUSB64(ByVal buf As Byte()) As Integer
    End Function

    <DllImport([Ô]\Win32\WINPPLA.DLL[Ô],EntryPoint:= [Ô]A_GetUSBBufferLen[Ô])>
    Private Function A_GetUSBBufferLen32() As Integer
    End Function
    <DllImport([Ô]\Win32\WINPPLA.DLL[Ô], EntryPoint:= [Ô]A_EnumUSB[Ô])>
    Private Function A_EnumUSB32(ByVal buf As Byte()) As Integer
    End Function


    Public Function GetUSBBufferLen() As Integer
        If IntPtr.Size = 4 Then
            [ô]32 bits
            return A_GetUSBBufferLen32()
        Else
            [ô]64 bits
            return A_GetUSBBufferLen64()
        End If
    End Function

    Public function EnumUSB(ByVal buf As Byte()) As Integer
        If IntPtr.Size = 4 Then
            [ô]32 bits
            return A_EnumUSB32(buf)
        Else
            [ô]64 bits
            Return A_EnumUSB64(buf)
        End If
    End function

End Module

O que fiz foi declarar todas as funções com nomes diferentes e usei o EntryPoint do DllImport para definir o nome correto da função, e então criei uma outra função que chama a versão correta, seja de 32 ou de 64 bits.

Detalhe importante, eu não verifiquei se o sistema operacional é de 32 ou de 64 bits e sim se o seu programa é de 32 ou de 64 bits, e para isso eu verifiquei o tamanho do IntPtr, ele sempre vai ser 4 se o processo atual for de 32 bits e 8 se o processo for de 64 bits.

E lembrando que isso só vale se você estiver compilando o programa para AnyCPU e dependendo da versão do .Net e VS.Net você precisa desmarcar a opção [Ô]Prefer 32-bit[Ô], pois ele faz com que o programa rode em 32 bits mesmo em sistemas operacionais de 64 bits.

Se o seu programa for rodar apenas em 32 bits pode ignorar tudo isso e usar somente a DLL de 32 bits.
PLUGSOFTSM 13/06/2016 16:03:41
#463444
Citação:

:
Neste caso você não pode usar o #IF, #ELSE, #ENDIF, eles são para compilação condicional, ou seja, este IF é resolvido durante a compilação e parte do código pode ser incluída ou excluída do programa, isso é útil quando se precisa criar dois executáveis diferentes usando o mesmo código com pequenas diferenças.

No caso se está compilando seu programa para AnyCPU então eu diria para fazer assim

Imports System.Runtime.InteropServices

Module MinhasFuncoes

    <DllImport([Ô]Win64WINPPLA.DLL[Ô], EntryPoint:=[Ô]A_GetUSBBufferLen[Ô])>
    Private Function A_GetUSBBufferLen64() As Integer
    End Function
    <DllImport([Ô]Win64WINPPLA.DLL[Ô], EntryPoint:=[Ô]A_EnumUSB[Ô])>
    Private Function A_EnumUSB64(ByVal buf As Byte()) As Integer
    End Function

    <DllImport([Ô]Win32WINPPLA.DLL[Ô],EntryPoint:= [Ô]A_GetUSBBufferLen[Ô])>
    Private Function A_GetUSBBufferLen32() As Integer
    End Function
    <DllImport([Ô]Win32WINPPLA.DLL[Ô], EntryPoint:= [Ô]A_EnumUSB[Ô])>
    Private Function A_EnumUSB32(ByVal buf As Byte()) As Integer
    End Function


    Public Function GetUSBBufferLen() As Integer
        If IntPtr.Size = 4 Then
            [ô]32 bits
            return A_GetUSBBufferLen32()
        Else
            [ô]64 bits
            return A_GetUSBBufferLen64()
        End If
    End Function

    Public function EnumUSB(ByVal buf As Byte()) As Integer
        If IntPtr.Size = 4 Then
            [ô]32 bits
            return A_EnumUSB32(buf)
        Else
            [ô]64 bits
            Return A_EnumUSB64(buf)
        End If
    End function

End Module

O que fiz foi declarar todas as funções com nomes diferentes e usei o EntryPoint do DllImport para definir o nome correto da função, e então criei uma outra função que chama a versão correta, seja de 32 ou de 64 bits.

Detalhe importante, eu não verifiquei se o sistema operacional é de 32 ou de 64 bits e sim se o seu programa é de 32 ou de 64 bits, e para isso eu verifiquei o tamanho do IntPtr, ele sempre vai ser 4 se o processo atual for de 32 bits e 8 se o processo for de 64 bits.

E lembrando que isso só vale se você estiver compilando o programa para AnyCPU e dependendo da versão do .Net e VS.Net você precisa desmarcar a opção [Ô]Prefer 32-bit[Ô], pois ele faz com que o programa rode em 32 bits mesmo em sistemas operacionais de 64 bits.

Se o seu programa for rodar apenas em 32 bits pode ignorar tudo isso e usar somente a DLL de 32 bits.




Valeu mesmo amigo
Funcionou direitinho... era isso que eu precisava
Não sei como não me havia ocorrido essa ideia ainda
Muito grato mesmo
Tópico encerrado , respostas não são mais permitidas
Voltar