C'è qualche linguaggio là fuori che utilizza il codice di template?

Question

C'è qualche lingua che ha una forma di codice che modella? Lascia che ti spieghi cosa intendo ... Stavo lavorando ad un progetto C# in cui una delle mie classi era molto ripetitiva, una serie di getter e setter di proprietà.

public static int CustomerID 
    { 
     get 
     { 
      return SessionHelper.Get<int>("CustomerID", 0); // 0 is the default value 
     } 
     set 
     { 
      SessionHelper.Set("CustomerID", value); 
     } 
    } 

    public static int BasketID 
    { 
     get 
     { 
      return SessionHelper.Get<int>("BasketID", 0); // 0 is the default value 
     } 
     set 
     { 
      SessionHelper.Set("BasketID", value); 
     } 
    } 

... and so forth ... 

Mi rendo conto che questo potrebbe suddividere in un tipo, un nome e un valore predefinito.

Ho visto questo articolo, che è simile a quello che immagino, ma non ha spazio per i parametri (impostazione predefinita).

Generic Property in C#

Ma stavo pensando, ci sono molte volte in cui il codice si articola in modelli.

Ad esempio, la sintassi potrebbe andare in quanto tale:

public template SessionAccessor(obj defaultValue) : static this.type this.name 
{ 
    get 
    { 
      return SessionHelper.Get<this.type>(this.name.ToString(), defaultValue); 
    } 
    set 
    { 
      SessionHelper.Set(this.name.ToString(), value); 
    } 
} 

public int CustomerID(0), BasketID(0) with template SessionAccessor; 
public ShoppingCart Cart(new ShoppingCart()) with template SessionAccessor; // Class example 

Mi sento come se questo avrebbe un sacco di possibilità per iscritto succinta, del codice SECCO. Questo tipo di cose sarebbe alquanto realizzabile in C# con il riflesso, tuttavia è lento e questo dovrebbe essere fatto durante la compilazione.

Quindi, domanda: questo tipo di funzionalità è possibile in qualsiasi linguaggio di programmazione esistente?

Answer 1

Come ha commentato Marc Gravell, è un lavoro facile per T4 (Text Template Transformation Toolkit), che è un processore di templating integrato in Visual Studio, che può essere utilizzato con C# o VB e può generare qualsiasi cosa. È uno strumento, non una funzionalità di linguaggio incorporata.

aggiunge un file modello di testo (.tt) al progetto, il modello sarà il più semplice:

<#@ template debug="false" hostspecific="false" language="C#" #> 
<#@ output extension=".generated.cs" #> 
<# 
var properties = new[] { 
    new Property { Type = typeof(int), Name = "CustomerID", DefaultValue = 0 }, 
    new Property { Type = typeof(int), Name = "BasketID", DefaultValue = 0 }, 
}; 
#> 
namespace YourNameSpace { 
    public partial class YourClass { 
<# foreach (Property property in properties) { #> 
     public static <#= property.Type.FullName #> <#= property.Name #> { 
      get { return SessionHelper.Get<<#= property.Type.FullName #>>("<#= property.Name #>", <#= property.DefaultValue #>); } 
      set { SessionHelper.Set("<#= property.Name #>", value); } 
     } 
<# } #> 
    } 
} 
<#+ 
public class Property { 
    public Type Type { get; set; } 
    public string Name { get; set; } 
    public object DefaultValue { get; set; } 
} 
#> 

T4 sono grandi per questo tipo di generazione del codice. Consiglio vivamente lo T4 Toolbox di generare facilmente più file per modello, accedere a EnvDTE per analizzare il codice C# esistente direttamente in Visual Studio e altro.

Answer 2

... e avete scoperto il meraviglioso mondo di metaprogramming. Benvenuto! :-)

Il linguaggio di metaprogrammazione archetipo è Lisp o in realtà qualsiasi altro linguaggio che può rappresentare la propria struttura nel codice.

Altre lingue hanno provato a copiare questo in una certa misura; macros in C sono un esempio prominente.

I più recenti candidati di lingue che supportano in qualche misura questo numero sono C++ via its templates e Ruby.