it-swarm-fr.com

Toute utilisation réelle des pointeurs en C #?

Qu'est-ce qu'une situation tout en codant en C # où l'utilisation des pointeurs est une option bonne ou nécessaire? Je parle de dangereux pointeurs.

19
Gulshan

du développeur de C # lui-même:

L'utilisation de pointeurs est rarement requise dans C #, mais certaines situations qui les nécessitent. À titre d'exemples, l'utilisation d'un contexte dangereux pour permettre aux pointeurs est justifiée par les cas suivants:

  • Traiter avec les structures existantes sur le disque
  • COMB ou plate-forme avancé invoque des scénarios qui impliquent des structures avec des pointeurs d'eux
  • Code critique de la performance

L'utilisation d'un contexte dangereux dans d'autres situations est découragé.

Spécifiquement, un contexte dangereux ne doit pas être utilisé pour tenter d'écrire C code en C #.

ATTENTION: "Le code écrit à l'aide d'un contexte dangereux ne peut pas être vérifié pour être sûr, il sera donc exécuté uniquement lorsque le code est entièrement fiable. En d'autres termes. En d'autres termes. En d'autres termes , le code dangereux ne peut pas être exécuté dans un environnement non approuvé. Par exemple, vous ne pouvez pas exécuter de code dangereux directement à partir d'Internet. "

Vous pouvez passer à travers ceci pour référence

25
ykombinator

oui, il existe de vrais utilisations, lorsque la performance est critique et que les opérations sont de faible niveau

par exemple, je n'ai besoin que d'utiliser des pointeurs en C # une fois, pour la comparaison d'images. Utilisation de GetPixel sur une paire d'images 1024x1024x32 a pris 2 minutes pour faire la comparaison (correspondance exacte). En pinçant la mémoire d'image et l'utilisation des pointeurs a pris moins de 1 seconde (sur la même machine bien sûr).

18
Steven A. Lowe

Vous devez vous rappeler que les concepteurs de Microsoft sont des personnes intelligentes et tout ce qu'ils ajoutent à C # a au moins 1 cas d'utilisation. Le Projet FPARSEC utilise un code dangereux pour faire ressortir chaque dernière goutte de performance que c # est capable de. Prenez notification de l'utilisation de fixed et stackalloc.

private char* ReadCharsFromStream(char* buffer, int maxCount, out string overhangChars) {
    Debug.Assert(maxCount >= 0);
    fixed (byte* byteBuffer = ByteBuffer) {
        overhangChars = null;
        try {
            while (maxCount >= MaxCharCountForOneByte) {// if maxCount < MaxCharCountForOneByte, Convert could throw
                int nBytesInByteBuffer = FillByteBuffer();
                bool flush = nBytesInByteBuffer == 0;
                int bytesUsed, charsUsed; bool completed = false;
                Decoder.Convert(byteBuffer + ByteBufferIndex, nBytesInByteBuffer,
                                buffer, maxCount, flush,
                                out bytesUsed, out charsUsed, out completed);
                ByteBufferIndex += bytesUsed; // GetChars consumed bytesUsed bytes from the byte buffer
                buffer += charsUsed;
                maxCount -= charsUsed;
                if (flush && completed) return buffer;
            }
            if (maxCount == 0) return buffer;

            char* cs = stackalloc char[MaxCharCountForOneByte];
            for (;;) {
                int nBytesInByteBuffer = FillByteBuffer();
                bool flush = nBytesInByteBuffer == 0;
                int bytesUsed, charsUsed; bool completed;
                Decoder.Convert(byteBuffer + ByteBufferIndex, nBytesInByteBuffer,
                                cs, MaxCharCountForOneByte, flush,
                                out bytesUsed, out charsUsed, out completed);
                ByteBufferIndex += bytesUsed;
                if (charsUsed > 0) {
                    int i = 0;
                    do {
                        *(buffer++) = cs[i++];
                        if (--maxCount == 0) {
                            if (i < charsUsed) overhangChars = new string(cs, i, charsUsed - i);
                            return buffer;
                        }
                    } while (i < charsUsed);
                }
                if (flush && completed) return buffer;
            }
        } catch (DecoderFallbackException e) {
            e.Data.Add("Stream.Position", ByteIndex + e.Index);
            throw;
        }
    }
}
6
ChaosPandion

Une fois, j'ai dû utiliser des pointeurs (dans le contexte dangereux) dans une application Windows basée sur C # qui servirait d'interface à un casque. Cette application est une interface utilisateur permettant aux agents (dans un centre d'appels) de contrôler leurs paramètres de casque. Cette application agit comme un alternant au panneau de commande indiqué par le fabricant de casque. Ainsi, leur capacité à contrôler les casques était limitée par rapport aux options disponibles. J'ai dû utiliser des pointeurs parce que je devais utiliser l'API (une DLL visuelle C++) fournie par le fabricant de casque à l'aide de P/invoke.

4
k25