preprocesamiento - Definiciones de macros de C#en el preprocesador

funcion preprocesador en c++

Question

¿Es capaz C # de definir macros como se hace en el lenguaje de programación C con declaraciones del preprocesador? Me gustaría simplificar la escritura regular de ciertas declaraciones repetitivas como las siguientes:

Console.WriteLine("foo");

Answer 1

Afortunadamente, C # no tiene preprocesador de estilo C / C ++, solo se admiten la compilación condicional y los pragmas (y posiblemente algo más que no puedo recordar). Desafortunadamente, C # no tiene capacidades de metaprogramación (esto puede estar relacionado con su pregunta hasta cierto punto).

Answer 2

Como C # 7.0 admite el using static directivas using static y funciones locales , no necesita macros de preprocesador para la mayoría de los casos.

Answer 3

Convierta la macro C en un método estático C # en una clase.

Answer 4

No hay un equivalente directo a las macros de estilo C en C #, pero los métodos estáticos en inline - con o sin #if / #elseif / #else pragmas - es lo más cercano que puede obtener:

        /// <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;
                }
            }
        }

Esto funciona perfectamente como una macro, pero tiene un pequeño inconveniente: los métodos marcados como en inline d se copiarán a la parte de reflexión de su ensamblaje como cualquier otro método "normal".

Answer 5

No, C # no admite macros de preprocesador como C. Visual Studio por otro lado tiene snippets . Los fragmentos de Visual Studio son una característica del IDE y se expanden en el editor en lugar de ser reemplazados por el preprocesador en el código de la compilación.

Answer 6

Puede usar un preprocesador de C (como mcpp) y colocarlo en su archivo .csproj. Luego cambia la "acción de compilación" en su archivo fuente desde Compilar a Preproceso o como se llame. Solo agrega BeforBuild a tu .csproj de esta manera:

  <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>

Es posible que tenga que cambiar manualmente Compilar a Preproceso en al menos un archivo (en un editor de texto); luego, la opción "Preproceso" debe estar disponible para su selección en Visual Studio.

Sé que las macros son muy utilizadas en exceso y mal utilizadas, pero eliminarlas por completo es igualmente malo, si no peor. Un ejemplo clásico de uso de macros sería NotifyPropertyChanged . Cada programador que tuvo que volver a escribir este código a mano miles de veces sabe lo doloroso que es sin macros.

Answer 7

Si bien no puede escribir macros, cuando se trata de simplificar cosas como su ejemplo, C # 6.0 ahora ofrece usos estáticos. Aquí está el ejemplo que dio Martin Pernica en su artículo de Medium :

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;
    }
  }
}

Answer 8

Te sugiero que escribas una extensión, algo como abajo.

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);
    }
}

Espero que esto ayude (y no demasiado tarde :))

Answer 9

Uso esto para evitar Console.WriteLine(...) :

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

y luego puedes usar lo siguiente:

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

Es conciso y algo funky.