protected   SqlCommand BuildCommand(string commandtText, params SqlParameter[] parameters)
        {
            SqlCommand ret = new SqlCommand();
            ret.CommandType = CommandType.StoredProcedure;
            ret.CommandText = commandtText;

            ret.Parameters.AddRange(parameters.Where(n => n != null).ToArray());

            return ret;
        }

 protected BuildCommand( commandtText:string, params  parameters:SqlParameter[]):SqlCommand
        {
            def ret:SqlCommand = SqlCommand();
            ret.CommandType = CommandType.StoredProcedure;
            ret.CommandText = commandtText;

            ret.Parameters.AddRange(parameters.Where(n => n != null).ToArray());
        }

if (skipEmpty == true && value == null)
                return null;

match(skipEmpty){
                | true => match(value)
                {
                    | null=>null 
                    | _ => () 
                }   
                | false => ()
            }

D>if (skipEmpty == true && value == null)
D>                return null;
D>

match (skipEmpty, value)
{
| ( true, null) => null
| _ => ()
}

C>match (skipEmpty, value)
C>{
C>| ( true, null) => null
C>| _ => ()
C>}
C>

protected  CreateParameter( name:string, value:object, skipEmpty: bool):SqlParameter
        {
            match(value, skipEmpty)
            {
                | (null, true) =>null
                | _ => ()
            }

            

            def param =   SqlParameter();
            param.ParameterName = string.Format("@{0}", name);
            param.Direction = ParameterDirection.Input;
            param.Value = value ?? DBNull.Value;
            param.SourceColumn = name;

            param;
        }

match (skipEmpty, value)
{
| ( true, null) => return null;
| _ => ()
}

using Nemerle.Extensions; // вместе с остальными using-ами

protected  CreateParameter( name:string, value:object, skipEmpty: bool):SqlParameter
        {
            match(value, skipEmpty)
            {
                | (null, true) =>null

                | _ => 
                    SqlParameter() <- {
                      ParameterName = string.Format("@{0}", name);
                      Direction = ParameterDirection.Input;
                      Value = value ?? DBNull.Value;
                      SourceColumn = name;
                   }
            }
        }

using Nemerle.Extensions; // вместе с остальными using-ами

protected CreateParameter(name : string, value : object, skipEmpty : bool) : SqlParameter
{
  | (_, null, true) => // либо, для читабельности, _ when value == null && skipEmpty
    null

  | _ => 
    SqlParameter() <- {
      ParameterName = "@" + name;
      Direction = ParameterDirection.Input;
      Value = value ?? DBNull.Value;
      SourceColumn = name;
    }
}

protected  CreateParameter( name:string, value:object, skipEmpty: bool):SqlParameter
        {
            match(value, skipEmpty)
            {
                | (null, true) =>null

                | _ => 
                    SqlParameter() <- {
                      ParameterName = string.Format("@{0}", name);
                      Direction = ParameterDirection.Input;
                      Value = value ?? DBNull.Value;
                      SourceColumn = name;
                   }
            }
        }

protected  CreateParameter( name:string, value:object, skipEmpty: bool):SqlParameter
        {
            match(value, skipEmpty)
            {
                | (null, true) =>null

                | _ => 
                   def param = SqlParameter();
                      param.ParameterName = string.Format("@{0}", name);
                      param.Direction = ParameterDirection.Input;
                      param.Value = value ?? DBNull.Value;
                      param.SourceColumn = name;
                      param;
            }
        }

Строка, начинающаяся со знака «$», может иметь в себе, скажем так, активные области (splices). Если внутри строки встречается одиночный символ «$», и дальше идет выражение, то его значение вычисляется и преобразуется в строку путем вызова у результирующего объекта метода ToString(). В качестве выражения может выступать идентификатор или произвольное выражение, взятое в скобки.

throw new InvalidArgumentException(string.Format("Неверная операция {0} для объекта {1} в состоянии {2}", cmd.OperationType, obj, obj.State));

throw InvalidArgumentException($"Неверная операция $(cmd.OperationType) для объекта $obj в состоянии $(obj.State)");

Console.WriteLine($"Посчитаем в $$-строке $(Math.Max(3 * 10, 5 + 2 * 10))");

Посчитаем в $-строке 30

//1
 protected   T ExecuteReader<T>(IDbCommand command, Func<IDataReader, T> func, bool isSingleRow = false)
        {
            
            using (var connection = new SqlConnection(this.ConnectionString))
            {
               //....................................
                using (IDataReader reader = command.ExecuteReader(combehavior))
                {
                    return func(reader);
                }
            }
        }

//2
        protected void ExecuteReader(IDbCommand command, Action<IDataReader> action, bool isSingleRow = false)
        {
            using (var connection = new SqlConnection(this.ConnectionString))
            {
               //....................................
                using (IDataReader reader = command.ExecuteReader(combehavior))
                {
                    action(reader);
                }
            }
        }


 private IEnumerable<BEArticle> Fill(SqlCommand command)
        {
            //3
            List<BEArticle> article = ExecuteReader(command, reader =>  article = reader.GetBEArticle().ToList());

//4
            for (int  i = 0; i < article.Count; i++)
            {
                article[i].Category = category[i];
                yield return article[i];
            }
        }

using(def connection = SqlConnection(this.ConnectionString))
{
}

//есть версия с перехватом исключений в блоке:
using(def connection = SqlConnection(this.ConnectionString))
{
}
catch
{
  | e is SqlException => Console.WriteLine("Не соединились!");
}

public static Test(i : int = 5) : void

public static Ext(this s : string) : string

for(mutable i=0; i<10; i++)
{
  Console.WriteLine(i);
}

//есть возможность добавить блок "иначе" выполняющийся если тело цикла не выполнялось:

for(mutable i=0; i<-10; i++)
{
  Console.WriteLine(i);
} otherwise
{
  Console.WriteLine("Цикл не выполнялся вовсе!");
}

YieldTest() : IEnumerable[string]
{
  yield "aaa";
  yield "bbb";
}

using (connection = SqlConnection(this.ConnectionString))
// или 
using (def connection = SqlConnection(this.ConnectionString))

foreach (i in [0..x.Length])
  ..

foreach (elem in collection whith i)
  ..

//1
    T ExecuteReader<T>(IDbCommand command, Func<IDataReader, T> func, bool isSingleRow = false)
        {
            var combehavior = isSingleRow ? CommandBehavior.SingleRow : CommandBehavior.Default;
            using (var connection = new SqlConnection(this.ConnectionString))
            {
                command.Connection = connection;
                connection.Open();

                using (IDataReader reader = command.ExecuteReader(combehavior))
                {
                    return func(reader);
                }
            }
        }

//2
    BEArticle GetSingle(int? id, string friendlyUrl)
        {
            var command = /////////////................................;

            return ExecuteReader(command, reader =>
            {
               BEArticle article = reader.GetBEArticle().Single();

               if (reader.NextResult())
                   article.Category = reader.GetBECategory().Single();

               
                return article;
            });
        }

ExecuteReader[T](command : IDbCommand, func : IDataReader -> T /* разницы с делегатом не будет */, isSingleRow : bool = false) : T
{
  def combehavior = if(isSingleRow) CommandBehavior.SingleRow else CommandBehavior.Default;
  using (connection = SqlConnection(this.ConnectionString))
  {
    command.Connection = connection;
    connection.Open();
    using (reader = command.ExecuteReader(combehavior))
    {
      func(reader)
    }
  }
}


GetSingle(id : int?, friendlyUrl : string) : BEArticle
{
  def command = /////////////................................;

  ExecuteReader(command, reader =>
  {
     def article = reader.GetBEArticle().Single();

     when(reader.NextResult())
       article.Category = reader.GetBECategory().Single();

     article;
  });
}

...
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;

namespace MyDataMacros
{
  macro ExecuteReader(command, body, reader = null)
    syntax("query", Optional(reader), "(", command ")", body)
  {
    ExecuteReaderImpl.Build(command, body, reader, false)
  }

  macro ExecuteSingleRowReader(command, body, reader = null)
    syntax("query" "single", Optional(reader), "(", command ")", body)
  {
    ExecuteReaderImpl.Build(command, body, reader, true)
  }

  module ExecuteReaderImpl
  {
    public Build(command : PExpr, body : PExpr, reader : PExpr, isSingleRow : bool) : PExpr
    {
      match(reader)
      {
        | null with readerName = <[ $("reader" : usesite) ]>
        | <[ $(readerName : name) ]> =>
          def executeArgs = if(isSingleRow) [ <[ CommandBehavior.SingleRow ]>] else [];
          <[
            def command = $command;
            using (connection = SqlConnection(this.ConnectionString))
            {
              command.Connection = connection;
              connection.Open();
              using ($(readerName : name) = command.ExecuteReader(..$executeArgs))
              {
                $body
              }
            }
          ]>

        | x =>
          Message.Error(x.Location, $"expected identifier, got `$x'"); <[ () ]>
      }
    }
  }
}

...

GetSingle(id : int?, friendlyUrl : string) : BEArticle
{
  def command = /////////////................................;

  query(command) // переменая reader доступна внутри блока
  {
     def article = reader.GetBEArticle().Single();

     when(reader.NextResult())
       article.Category = reader.GetBECategory().Single();

     article
  }
}

fun(reader) 
{
...
}

 public partial class MyPage : System.Web.UI.Page {
        protected void Page_Init(object sender, EventArgs e) { }
        public static string PageUrl { get{ return "/Secure/App/MyPage.aspx";} }
}

//.....................................
void Foo(){
if (good)
 Response.Redirect(MyPage.GetPageUrl);
}

void Foo(){
if (good)
    Response.Redirect(/*????*/);
}

void Foo(){
if (good)
    Response.Redirect(this.PageUrl);
}

public partial class MyPage : System.Web.UI.Page {
 protected void Page_Init(object sender, EventArgs e) { }
 public static string PageUrl { get{ return "/Secure/App/MyPage.aspx";} }
 }



 public partial class MyPage2 : System.Web.UI.Page {
 protected void Page_Load(object sender, EventArgs e) {
   if (good)
      Response.Redirect(MyPage.GetPageUrl);
   }
 }

public class A {
  public virtual static void C() { Console.WriteLine("A"); }
}

public class B : A {
  public override static void C() { Console.WriteLine("B"); base(); }
}

class Program {
  public static void Main(string[] arguments) {
    A.C(); // Console.WriteLine("A")
    B.C(); // Console.WriteLine("B"); Console.WriteLine("A");
  }
}

class A {
  protected static void C1() { C2(); }
  protected virtual static void C2() { Console.WriteLine("A.C2"); }
}

class B : A {
  protected override static void C2() { Console.WriteLine("B.C2"); }
}

class Program {
  public static void Main(string[] arguments) {
    B.C1(); // B:C2
  }
}

module A {
  public C1() : void    { C2(); }
  protected C2() : void { Console.WriteLine("A.C2"); }
}

[OverrideStatic] // просто копирует все методы
module B : A {
  // сгенерированный макросом метод
  public C1() : void    { C2(); }

  protected C2() : void { Console.WriteLine("B.C2"); }
}

class Program {
  public static void Main(string[] arguments) {
    B.C1(); // B:C2
  }
}