Гибкая фильтрация данных запроса - C# - Ответ 7233764

Psilon · 16.02.2015, 13:16

sigmov, Да это не секрет, гуглите по T4 template

Например

Добавлено через 40 минут
Очень мощная штука. В моем случае вот ЭТО

Кликните здесь для просмотра всего текста

<#@ template language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="System.Reflection" #>
<#@ assembly name="$(TargetDir)$(TargetFileName)"

#>using System;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Web.UI.WebControls;
using Lanit.Audit.Models;

<#var props = typeof (Lanit.Audit.Models.AuditEntry).GetProperties(System.Reflection.BindingFlags.Ins tance | System.Reflection.BindingFlags.Public); #>

public static class AuditHelper
{
public static IOrderedEnumerable<AuditEntry> OrderBy(this IEnumerable<AuditEntry> collection, string property)
{
switch(property)
{
<# foreach (var prop in props) {
#>case "<#=prop.Name#>":
return collection.OrderBy(x=>x.<#=prop.Name#>);
<# }
#>}
throw new NotImplementedException();
}

public static IOrderedEnumerable<AuditEntry> OrderByDescending(this IEnumerable<AuditEntry> collection, string property)
{
switch(property)
{
<# foreach (var prop in props) {
#>case "<#=prop.Name#>":
return collection.OrderByDescending(x=>x.<#=prop.Name#>);
<# }
#>}
throw new NotImplementedException();
}

public static IOrderedEnumerable<AuditEntry> OrderBy(this IEnumerable<AuditEntry> collection, string property, SortDirection directon)
{
return directon == SortDirection.Ascending ? collection.OrderBy(property) : collection.OrderByDescending(property);
}

public static IComparer<AuditEntry> GetComparer(string property, SortDirection directon)
{
switch(property)
{
<#foreach (var prop in props) {
#>case "<#=prop.Name#>":
return directon == SortDirection.Ascending ? (IComparer<AuditEntry>) new <#=prop.Name#>Comparer() : new <#=prop.Name#>ComparerDescendant();
<# }
#>}
throw new NotImplementedException();
}

public static bool RegexIsMatch(this AuditEntry entry, string pattern, string property)
{
var regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
switch(property)
{
<# foreach (var prop in props) {
#>case "<#=prop.Name#>":
return regex.IsMatch(entry.<#= prop.Name + (prop.PropertyType == typeof (string) ? "" : ".ToString()")#>);
<# }
#>}
throw new NotImplementedException();
}

public static IEnumerable<AuditEntry> WhereRegexIsMatch(this IEnumerable<AuditEntry> collection, string pattern, string property)
{
var regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
switch(property)
{
<# foreach (var prop in props) {
#>case "<#=prop.Name#>":
return collection.Where(x => regex.IsMatch(x.<#= prop.Name + (prop.PropertyType == typeof (string) ? "" : ".ToString()")#>));
<# }
#>}
throw new NotImplementedException();
}
}

<# foreach (var prop in props) { #>

public class <#=prop.Name#>Comparer : IComparer<AuditEntry>
{
public int Compare(AuditEntry x, AuditEntry y)
{
return x.<#=prop.Name#>.CompareTo(y.<#=prop.Name#>);
}
}

public class <#=prop.Name#>ComparerDescendant : IComparer<AuditEntry>
{
public int Compare(AuditEntry x, AuditEntry y)
{
return y.<#=prop.Name#>.CompareTo(x.<#=prop.Name#>);
}
}

<# } #>

превращается в

Кликните здесь для просмотра всего текста

C#

using System;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Web.UI.WebControls;
using Lanit.Audit.Models;
 
 
public static class AuditHelper
{
    public static IOrderedEnumerable<AuditEntry> OrderBy(this IEnumerable<AuditEntry> collection, string property)
    {   
        switch(property)
        {
            case "ItemId":          
                return collection.OrderBy(x=>x.ItemId);
            case "ItemType":            
                return collection.OrderBy(x=>x.ItemType);
            case "DocLocation":             
                return collection.OrderBy(x=>x.DocLocation);
            case "Event":           
                return collection.OrderBy(x=>x.Event);
            case "UserId":          
                return collection.OrderBy(x=>x.UserId);
            case "Occurred":            
                return collection.OrderBy(x=>x.Occurred);
            }
        throw new NotImplementedException();
    }
 
    public static IOrderedEnumerable<AuditEntry> OrderByDescending(this IEnumerable<AuditEntry> collection, string property)
    {  
        switch(property)
        {
            case "ItemId":          
                return collection.OrderByDescending(x=>x.ItemId);
            case "ItemType":            
                return collection.OrderByDescending(x=>x.ItemType);
            case "DocLocation":             
                return collection.OrderByDescending(x=>x.DocLocation);
            case "Event":           
                return collection.OrderByDescending(x=>x.Event);
            case "UserId":          
                return collection.OrderByDescending(x=>x.UserId);
            case "Occurred":            
                return collection.OrderByDescending(x=>x.Occurred);
            }
        throw new NotImplementedException();
    }
 
    public static IOrderedEnumerable<AuditEntry> OrderBy(this IEnumerable<AuditEntry> collection, string property, SortDirection directon)
    {
      return directon == SortDirection.Ascending ? collection.OrderBy(property) : collection.OrderByDescending(property); 
    }
 
    public static IComparer<AuditEntry> GetComparer(string property, SortDirection directon)
    {
      switch(property)
      {
         case "ItemId":
            return directon == SortDirection.Ascending ? (IComparer<AuditEntry>) new ItemIdComparer() : new ItemIdComparerDescendant();   
         case "ItemType":
            return directon == SortDirection.Ascending ? (IComparer<AuditEntry>) new ItemTypeComparer() : new ItemTypeComparerDescendant();   
         case "DocLocation":
            return directon == SortDirection.Ascending ? (IComparer<AuditEntry>) new DocLocationComparer() : new DocLocationComparerDescendant();   
         case "Event":
            return directon == SortDirection.Ascending ? (IComparer<AuditEntry>) new EventComparer() : new EventComparerDescendant();   
         case "UserId":
            return directon == SortDirection.Ascending ? (IComparer<AuditEntry>) new UserIdComparer() : new UserIdComparerDescendant();   
         case "Occurred":
            return directon == SortDirection.Ascending ? (IComparer<AuditEntry>) new OccurredComparer() : new OccurredComparerDescendant();   
         }
        throw new NotImplementedException();
    }
 
    public static bool RegexIsMatch(this AuditEntry entry, string pattern, string property)
    {
        var regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
        switch(property)
        {
            case "ItemId":          
                return regex.IsMatch(entry.ItemId.ToString());
            case "ItemType":            
                return regex.IsMatch(entry.ItemType);
            case "DocLocation":             
                return regex.IsMatch(entry.DocLocation);
            case "Event":           
                return regex.IsMatch(entry.Event);
            case "UserId":          
                return regex.IsMatch(entry.UserId.ToString());
            case "Occurred":            
                return regex.IsMatch(entry.Occurred.ToString());
            }        
        throw new NotImplementedException();
    }
 
    public static IEnumerable<AuditEntry> WhereRegexIsMatch(this IEnumerable<AuditEntry> collection, string pattern, string property)
    {
        var regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
        switch(property)
        {
            case "ItemId":          
                return collection.Where(x => regex.IsMatch(x.ItemId.ToString()));
            case "ItemType":            
                return collection.Where(x => regex.IsMatch(x.ItemType));
            case "DocLocation":             
                return collection.Where(x => regex.IsMatch(x.DocLocation));
            case "Event":           
                return collection.Where(x => regex.IsMatch(x.Event));
            case "UserId":          
                return collection.Where(x => regex.IsMatch(x.UserId.ToString()));
            case "Occurred":            
                return collection.Where(x => regex.IsMatch(x.Occurred.ToString()));
            }          
        throw new NotImplementedException();
    }
}
 
 
 
public class ItemIdComparer : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return x.ItemId.CompareTo(y.ItemId);
    }
}
 
public class ItemIdComparerDescendant : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return y.ItemId.CompareTo(x.ItemId);
    }
}
 
 
public class ItemTypeComparer : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return x.ItemType.CompareTo(y.ItemType);
    }
}
 
public class ItemTypeComparerDescendant : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return y.ItemType.CompareTo(x.ItemType);
    }
}
 
 
public class DocLocationComparer : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return x.DocLocation.CompareTo(y.DocLocation);
    }
}
 
public class DocLocationComparerDescendant : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return y.DocLocation.CompareTo(x.DocLocation);
    }
}
 
 
public class EventComparer : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return x.Event.CompareTo(y.Event);
    }
}
 
public class EventComparerDescendant : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return y.Event.CompareTo(x.Event);
    }
}
 
 
public class UserIdComparer : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return x.UserId.CompareTo(y.UserId);
    }
}
 
public class UserIdComparerDescendant : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return y.UserId.CompareTo(x.UserId);
    }
}
 
 
public class OccurredComparer : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return x.Occurred.CompareTo(y.Occurred);
    }
}
 
public class OccurredComparerDescendant : IComparer<AuditEntry>
{
    public int Compare(AuditEntry x, AuditEntry y)
    {
        return y.Occurred.CompareTo(x.Occurred);
    }
}

Мне норм

Вернуться к обсуждению:
Гибкая фильтрация данных запроса C#

Следующий ответ