C # -Makrodefinitionen im Präprozessor

Kann C # Makros wie in der Programmiersprache C mit Pre-Prozessor-Anweisungen definieren? Ich möchte die regelmäßige Eingabe bestimmter sich wiederholender Anweisungen wie der folgenden vereinfachen:

Console.WriteLine("foo");

Nein, C # unterstützt keine Präprozessor-Makros wie C. Visual Studio verfügt dagegen über Snippets . Die Ausschnitte von Visual Studio sind eine Funktion der IDE und werden im Editor erweitert, anstatt beim Kompilieren durch einen Präprozessor im Code ersetzt zu werden.

Sie können einen C-Präprozessor (wie mcpp) verwenden und ihn in Ihre .csproj-Datei einbinden. Dann ändern Sie "Build Action" für Ihre Quelldatei von Compile to Preprocess oder wie auch immer Sie es nennen. Fügen Sie einfach BeforBuild zu Ihrem CSPROJ wie folgt aus :

  <Target Name="BeforeBuild" Inputs="@(Preprocess)" Outputs="@(Preprocess->'%(Filename)_P.cs')">
<Exec Command="..\Bin\cpp.exe @(Preprocess) -P -o %(RelativeDir)%(Filename)_P.cs" />
<CreateItem Include="@(Preprocess->'%(RelativeDir)%(Filename)_P.cs')">
  <Output TaskParameter="Include" ItemName="Compile" />
</CreateItem>

Möglicherweise müssen Sie die Kompilierung für mindestens eine Datei (in einem Texteditor) manuell in Vorverarbeitung ändern. Dann sollte die Option "Vorverarbeitung" in Visual Studio zur Auswahl verfügbar sein.

Ich weiß, dass Makros stark überbeansprucht und missbraucht werden, aber das vollständige Entfernen ist genauso schlecht, wenn nicht schlimmer. Ein klassisches Beispiel für die Verwendung von Makros wäre NotifyPropertyChanged . Jeder Programmierer, der diesen Code tausende Male von Hand umschreiben musste, weiß, wie schmerzhaft er ohne Makros ist.

Ich benutze dies, um Folgendes zu vermeiden Console.WriteLine(...):

public static void Cout(this string str, params object[] args) { 
    Console.WriteLine(str, args);
}

und dann können Sie Folgendes verwenden:

"line 1".Cout();
"This {0} is an {1}".Cout("sentence", "example");

Es ist prägnant und irgendwie funky.

Während Sie keine Makros schreiben können, bietet C # 6.0 jetzt statische Verwendungen, wenn es darum geht, Dinge wie Ihr Beispiel zu vereinfachen. Hier ist das Beispiel, das Martin Pernica in seinem Medium-Artikel gegeben hat :

using static System.Console; // Note the static keyword

namespace CoolCSharp6Features
{
  public class Program
  {
    public static int Main(string[] args)
    {
      WriteLine("Hellow World without Console class name prefix!");

      return 0;
    }
  }
}

Es gibt kein direktes Äquivalent zu Makros im C-Stil in C #, aber inlined statische Methoden - mit oder ohne #if/ #elseif/ #elsePragmas - sind die nächsten, die Sie erhalten können:

        /// <summary>
        /// Prints a message when in debug mode
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static unsafe void Log(object message) {
#if DEBUG
            Console.WriteLine(message);
#endif
        }

        /// <summary>
        /// Prints a formatted message when in debug mode
        /// </summary>
        /// <param name="format">A composite format string</param>
        /// <param name="args">An array of objects to write using format</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static unsafe void Log(string format, params object[] args) {
#if DEBUG
            Console.WriteLine(format, args);
#endif
        }

        /// <summary>
        /// Computes the square of a number
        /// </summary>
        /// <param name="x">The value</param>
        /// <returns>x * x</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static double Square(double x) {
            return x * x;
        }

        /// <summary>
        /// Wipes a region of memory
        /// </summary>
        /// <param name="buffer">The buffer</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static unsafe void ClearBuffer(ref byte[] buffer) {
            ClearBuffer(ref buffer, 0, buffer.Length);
        }

        /// <summary>
        /// Wipes a region of memory
        /// </summary>
        /// <param name="buffer">The buffer</param>
        /// <param name="offset">Start index</param>
        /// <param name="length">Number of bytes to clear</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static unsafe void ClearBuffer(ref byte[] buffer, int offset, int length) {
            fixed(byte* ptrBuffer = &buffer[offset]) {
                for(int i = 0; i < length; ++i) {
                    *(ptrBuffer + i) = 0;
                }
            }
        }

Dies funktioniert perfekt als Makro, hat jedoch einen kleinen Nachteil: Mit inlined gekennzeichnete Methoden werden wie jede andere "normale" Methode in den Reflexionsteil Ihrer Baugruppe kopiert.

Glücklicherweise hat C # keinen Präprozessor im C / C ++ - Stil - nur bedingte Kompilierung und Pragmas (und möglicherweise etwas anderes, an das ich mich nicht erinnern kann) werden unterstützt. Leider verfügt C # über keine Metaprogrammierfunktionen (dies kann in gewissem Maße tatsächlich mit Ihrer Frage zusammenhängen).

Verwandeln Sie das C-Makro in eine statische C # -Methode in einer Klasse.

Ich würde Ihnen vorschlagen, eine Erweiterung zu schreiben, so etwas wie unten.

public static class WriteToConsoleExtension
{
   // Extension to all types
   public static void WriteToConsole(this object instance, 
                                     string format, 
                                     params object[] data)
   {
       Console.WriteLine(format, data);
   }
}

class Program
{
    static void Main(string[] args)
    {
        Program p = new Program();
        // Usage of extension
        p.WriteToConsole("Test {0}, {1}", DateTime.Now, 1);
    }
}

Hoffe das hilft (und nicht zu spät :))

Da C # 7.0 using staticDirektiven- und lokale Funktionen unterstützt, benötigen Sie in den meisten Fällen keine Präprozessormakros.

Ich werde einen C # -Makrocompiler namens C # -Makros erstellen.

Fortschritt ist hier .