The CSharp(x, cgopts) calling sequence translates Maple code to C# code.

- If the parameter x is an algebraic expression, then a C# statement assigning the expression to a variable is generated.

- If x is a list, Maple Array, or rtable of algebraic expressions, then a sequence of C# statements assigning the elements to a C# array is produced.  Only the initialized elements of the rtable or Maple Array are translated.

- If x is a list of equations $\mathrm{nm}=\mathrm{expr}$ where $\mathrm{nm}$ is a name and $\mathrm{expr}$ is an algebraic expression, then this is understood to be a sequence of assignment statements.  In this case, the equivalent sequence of C# assignment statements is generated.

- If x is a procedure, then a C# class is generated containing a function equivalent to the procedure, along with any necessary import statements.

- If x is a module, then a C# class is generated, as described on the CSharpDetails help page.

The parameter cgopts may include one or more CodeGeneration options, as described in CodeGenerationOptions.

For more information about how the CodeGeneration package translates Maple code to other languages, see Translation Details. For more information about translation to C# in particular, see CSharpDetails.

$\mathrm{with}\left(\mathrm{CodeGeneration}\right)\:$

$\mathrm{CSharp}\left(x+yz-2xz\,\mathrm{resultname}=''w''\right)$

w = -2 * x * z + y * z + x;

$\mathrm{CSharp}\left(\left[\left[x\,2y\right]\,\left[5\,z\right]\right]\,\mathrm{resultname}=''w''\right)$

w[0,0] = x;
w[0,1] = 2 * y;
w[1,0] = 5;
w[1,1] = z;

$\mathrm{cs}≔\left[s=1.0+x\,t=\ln \left(s\right)\exp \left(-x\right)\,r=\exp \left(-x\right)+xt\right]\:$

$\mathrm{CSharp}\left(\mathrm{cs}\,\mathrm{optimize}\right)$

s = 0.10e1 + x;
t1 = Math.Log(s);
t2 = Math.Exp(-x);
t = t2 * t1;
r = x * t + t2;

$s≔\mathrm{CSharp}\left(x+y+1\,\mathrm{declare}=\left[x::\mathrm{float}\,y::\mathrm{integer}\right]\,\mathrm{output}=\mathrm{string}\right)$

$s≔''cg\; =\; x\; +\; (System.Double)\; y\; +\; 0.1e1;''$

f := proc(x, y, z) return x*y-y*z+x*z; end proc:

$\mathrm{CSharp}\left(f\,\mathrm{defaulttype}=\mathrm{integer}\right)$

public class CodeGenerationClass {
  public static System.Int32 f (System.Int32 x, System.Int32 y, System.Int32 z)
  {
    return y * x - y * z + x * z;
  }
}

f := proc(n)
  local x, i;
  x := 0.0;
  for i to n do
    x := x + i;
  end do;
end proc:

$\mathrm{CSharp}\left(f\right)$

public class CodeGenerationClass {
  public static System.Double f (System.Int32 n)
  {
    System.Double x;
    System.Int32 i;
    System.Double cgret;
    x = 0.0e0;
    for (i = 1; i <= n; i++)
    {
      x = x + (System.Double) i;
      cgret = x;
    }
    return cgret;
  }
}

f := proc(x::Array(numeric, 5..7))
  return x[5]+x[6]+x[7];
end proc:

$\mathrm{CSharp}\left(f\right)$

public class CodeGenerationClass {
  public static System.Double f (System.Double[] x)
  {
    return x[0] + x[1] + x[2];
  }
}

m := module() export p; local q;
    p := proc(x,y) if y>0 then trunc(x); else ceil(x); end if; end proc:
    q := proc(x) sin(x)^2; end proc:
end module:

$\mathrm{CSharp}\left(m\&comma;\mathrm{resultname}=\mathrm{t0}\right)$

using System;

public class m {
  public static System.Int32 p (System.Double x, System.Int32 y)
  {
    if (0 < y)
      return (System.Int32)(x);
    else
      return (System.Int32)Math.Ceiling(x);
  }
  private static System.Double q (System.Double x)
  {
    return Math.Pow(Math.Sin(x), 0.2e1);
  }
}

$\mathrm{CSharp}\left(2\cosh \left(x\right)-7\tanh \left(x\right)\right)$

cg0 = 0.2e1 * (Math.Exp(x) + Math.Exp((-0.1e1) * x)) / 0.2e1 - 0.7e1 * (Math.Exp(0.2e1 * x) - 0.1e1) / (Math.Exp(0.2e1 * x) + 0.1e1);

f := proc(a::integer, p::integer)
  printf("The integer remainder of %d divided by %d is: %d\n", a, p, irem(a, p));
end proc:

$\mathrm{CSharp}\left(f\right)$

using System;

public class CodeGenerationClass {
  public static void f (System.Int32 a, System.Int32 p)
  {
    Console.WriteLine("The integer remainder of " + a + " divided by " + p + " is: " + a % p);
  }
}

The CodeGeneration[CSharp] command was introduced in Maple 15.

For more information on Maple 15 changes, see Updates in Maple 15.