C#.NET Class拡張ToJson/select/IsBetween/In/Compress/Sealize

27436 ワード


  
    
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Data;
using System.Data.Common;
using System.Web.Script.Serialization;
using System.IO;
using System.Security.Cryptography;
using System.Runtime.Serialization.Formatters.Binary;

namespace Pub.Class {
public static class ClassExtensions {

public static string ToJson < TSource, TResult > ( this TSource entity, Func < TSource, TResult > selector) {
List
< TSource > oblist = new List < TSource > ();
oblist.Add(entity);
string str = oblist.Select(selector).ToJson();
return str.Substring( 1 , str.Length - 2 );
}
public static TResult Select < TSource, TResult > ( this TSource entity, Func < TSource, TResult > selector) {
List
< TSource > oblist = new List < TSource > ();
oblist.Add(entity);
return oblist.Select(selector).ToList()[ 0 ];
}
public static bool EqualsAny < T > ( this T obj, params T[] values) {
return (Array.IndexOf(values, obj) != - 1 );
}

public static bool IsBetween < T > ( this T value, T minValue, T maxValue) where T : IComparable < T > {
return IsBetween(value, minValue, maxValue, null );
}
public static bool IsBetween < T > ( this T value, T minValue, T maxValue, IComparer < T > comparer) where T : IComparable < T > {
comparer
= comparer ?? Comparer < T > .Default;

var minMaxCompare
= comparer.Compare(minValue, maxValue);
if (minMaxCompare < 0 ) {
return ((comparer.Compare(value, minValue) >= 0 ) && (comparer.Compare(value, maxValue) <= 0 ));
}
else if (minMaxCompare == 0 ) {
return (comparer.Compare(value, minValue) == 0 );
}
else {
return ((comparer.Compare(value, maxValue) >= 0 ) && (comparer.Compare(value, minValue) <= 0 ));
}
}
public static bool In < T > ( this T source, params T[] values) where T : IEquatable < T > {
if (values == null ) return false ;
return IEnumerableExtensions.In(source, ((IEnumerable < T > )values));
}

public static byte [] Compress < T > ( this T data) where T : class {
return data.Serialize < T > ().Compress();
}

public static T Clone < T > ( this T o) where T : class {
Type type
= o.GetType().BaseType;

MethodInfo[] methodInfos
= type.GetMethods(BindingFlags.NonPublic
| BindingFlags.Instance
| BindingFlags.DeclaredOnly);
MethodInfo cloneMethod
= null ;
foreach (var item in methodInfos) {
if (item.Name == " MemberwiseClone " ) {
cloneMethod
= item;
break ;
}
}
if (cloneMethod != null ) return (T)cloneMethod.Invoke(o, null );
return default (T);
}
public static byte [] Serialize < T > ( this T o) where T : class {
Type type
= o.GetType();
if ((type.Attributes & TypeAttributes.Serializable) == 0 )
throw new Exception( " The Specified object must have [Serializable] attribute " );

var formatter
= new BinaryFormatter();
using (MemoryStream ms = new MemoryStream()) {
formatter.Serialize(ms, o);
return ms.ToArray();
}
}

public static R Pipe < T, R > ( this T o, Func < T, R > action) {
T buffer
= o;
return action(buffer);
}
public static T Pipe < T > ( this T o, Action < T > action) {
T buffer
= o;
action(buffer);
return buffer;
}

public static bool IsDefault < T > ( this T value) { return Equals(value, default (T)); }

// string s = "stringtest";
// Msg.Write(s.Compress<string>().Decompress<string>());
}
}

 
ToJson呼び出し
 

  
    

private void TaskDetailLoad(){
int id = Request2.GetFInt( " id " , 0 );
if (id <= 0 ) Msg.WriteEnd( " {} " );

Msg.WriteEnd(LP_TaskFactory.Instance().SelectByID(id).ToJson(p
=> new {
p.TaskID,
p.TaskName,
p.Quarter,
p.StartTime,
p.Intro,
Nodes
= LP_TaskDetailFactory.Instance().SelectListByTaskID(id, "" , "" , "" , true )
.Select(z
=> new {
z.TaskDetailID,
z.DetailMonths,
z.DetailName,
z.DetailType,
z.DetailIntro,
z.Days
})
}));
}