C#.NET Array扩展 Join/Compress/Decompress/Deserialize/IsInArray/Action
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.Globalization;
using
System.Collections;
using
System.IO;
using
System.Drawing;
using
System.IO.Compression;
using
System.Runtime.Serialization.Formatters.Binary;
namespace
Pub.Class {
public
static
class
ArrayExtensions {
public
static
bool
IsNullEmpty(
this
Array array) {
return
array
==
null
||
array.Length
==
0
; }
public
static
bool
IsNullEmpty(
this
ArrayList list) {
return
(list
==
null
)
||
(list.Count
==
0
); }
public
static
int
GetInArrayID(
this
string
[] stringArray,
string
strSearch,
bool
caseInsensetive) {
for
(
int
i
=
0
; i
<
stringArray.Length; i
++
) {
if
(caseInsensetive) {
if
(strSearch.ToLower()
==
stringArray[i].ToLower())
return
i;
}
else
{
if
(strSearch
==
stringArray[i])
return
i;
}
}
return
-
1
;
}
public
static
int
GetInArrayID(
this
string
[] stringArray,
string
strSearch) {
return
GetInArrayID(stringArray, strSearch,
true
);
}
public
static
string
ToDelimitedString
<
T
>
(
this
T[] array,
string
format,
string
delimiter) {
if
(array
==
null
||
array.Length
==
0
)
return
string
.Empty;
if
(format.IsNullEmpty()) format
=
"
{0}
"
;
StringBuilder builder
=
new
StringBuilder();
for
(
int
index
=
0
; index
<
array.Length;
++
index) {
if
(index
!=
0
) builder.Append(delimiter);
builder.AppendFormat(format, array[index]);
}
return
builder.ToString();
}
public
static
T[] RemoveDuplicates
<
T
>
(
this
T[] array) {
ArrayList al
=
new
ArrayList();
for
(
int
i
=
0
; i
<
array.Length; i
++
) {
if
(
!
al.Contains(array[i])) al.Add(array[i]);
}
return
(T[])al.ToArray(
typeof
(T));
}
public
static
T[] Slice
<
T
>
(
this
T[] array,
int
start,
int
end) {
if
(start
>=
array.Length) { start
=
0
; end
=
0
; }
if
(end
<
0
) end
=
array.Length
-
start
-
end;
if
(end
<=
start) end
=
start;
if
(end
>=
array.Length) end
=
array.Length
-
1
;
int
len
=
end
-
start
+
1
;
T[] res
=
new
T[len];
for
(
int
i
=
0
; i
<
len; i
++
) res[i]
=
array[i
+
start];
return
res;
}
public
static
string
Join
<
T
>
(
this
T[] array,
string
splitStr) {
StringBuilder sb
=
new
StringBuilder();
foreach
(T info
in
array) {
sb.AppendFormat(
"
{0}{1}
"
, info.ToString(), splitStr);
}
return
sb.ToString().Left(sb.Length
-
splitStr.Length);
}
public
static
void
Action
<
T
>
(
this
T[] inArray, Action
<
T, Int32
>
inAction) {
for
(
int
i0
=
0
; i0
<
inArray.GetLength(
0
); i0
++
) {
inAction(inArray[i0], i0);
}
}
public
static
void
Action
<
T
>
(
this
T[,] inArray, Action
<
T, Int32, Int32
>
inAction) {
for
(
int
i0
=
0
; i0
<
inArray.GetLength(
0
); i0
++
) {
for
(
int
i1
=
0
; i1
<
inArray.GetLength(
1
); i1
++
) inAction(inArray[i0, i1], i0, i1);
}
}
public
static
void
Action
<
T
>
(
this
T[,,] inArray, Action
<
T, Int32, Int32, Int32
>
inAction) {
for
(
int
i0
=
0
; i0
<
inArray.GetLength(
0
); i0
++
) {
for
(
int
i1
=
0
; i1
<
inArray.GetLength(
1
); i1
++
) {
for
(
int
i2
=
0
; i2
<
inArray.GetLength(
2
); i2
++
) inAction(inArray[i0, i1, i2], i0, i1, i2);
}
}
}
public
static
void
Action
<
T
>
(
this
T[,] inArray, Int32 inDimension, Int32 inIndex, Action
<
T, Int32
>
inAction) {
if
(inDimension
==
0
) {
for
(
int
i
=
0
; i
<
inArray.GetLength(
1
); i
++
) inAction(inArray[inIndex, i], i);
}
else
if
(inDimension
==
1
) {
for
(
int
i
=
0
; i
<
inArray.GetLength(
0
); i
++
) inAction(inArray[i, inIndex], i);
}
else
{
throw
new
ArgumentException(
"
inDimension must be zero or one
"
);
}
}
public
static
void
Action
<
T
>
(
this
T[,,] inArray, Int32 inDimension, Int32 inIndex, Action
<
T, Int32, Int32
>
inAction) {
if
(inDimension
==
0
) {
for
(
int
i0
=
0
; i0
<
inArray.GetLength(
1
); i0
++
) {
for
(
int
i1
=
0
; i1
<
inArray.GetLength(
2
); i1
++
) inAction(inArray[inIndex, i0, i1], i0, i1);
}
}
else
if
(inDimension
==
1
) {
for
(
int
i0
=
0
; i0
<
inArray.GetLength(
0
); i0
++
){
for
(
int
i1
=
0
; i1
<
inArray.GetLength(
2
); i1
++
) inAction(inArray[i0, inIndex, i1], i0, i1);
}
}
else
if
(inDimension
==
2
) {
for
(
int
i0
=
0
; i0
<
inArray.GetLength(
0
); i0
++
){
for
(
int
i1
=
0
; i1
<
inArray.GetLength(
1
); i1
++
) inAction(inArray[i0, i1, inIndex], i0, i1);
}
}
else
{
throw
new
ArgumentException(
"
inDimension must be zero or one or two
"
);
}
}
public
static
Image ToImage(
this
byte
[] bytes) {
if
(bytes
!=
null
) {
MemoryStream ms
=
new
MemoryStream(bytes,
0
, bytes.Length);
ms.Write(bytes,
0
, bytes.Length);
return
Image.FromStream(ms,
true
);
}
return
null
;
}
public
static
bool
ToFile(
this
byte
[] bytes,
string
fileName, FileMode fileMode) {
bool
returnValue
=
true
;
FileAccess fileAccess
=
FileAccess.ReadWrite;
if
(fileMode
==
FileMode.Append) fileAccess
=
FileAccess.Write;
FileStream fs
=
new
FileStream(fileName, fileMode, fileAccess);
BinaryWriter bw
=
new
BinaryWriter(fs);
try
{ bw.Write(bytes); }
catch
(Exception) { returnValue
=
false
; }
finally
{ fs.Close(); bw.Close(); }
return
returnValue;
}
public
static
byte
[] Compress(
this
byte
[] data) {
using
(MemoryStream output
=
new
MemoryStream()) {
using
(DeflateStream def
=
new
DeflateStream(output, CompressionMode.Compress)) {
def.Write(data,
0
, data.Length);
}
return
output.ToArray();
}
}
public
static
byte
[] Decompress(
this
byte
[] data) {
using
(MemoryStream input
=
new
MemoryStream()) {
input.Write(data,
0
, data.Length);
input.Position
=
0
;
using
(DeflateStream def
=
new
DeflateStream(input, CompressionMode.Decompress)) {
using
(MemoryStream output
=
new
MemoryStream()) {
byte
[] buff
=
new
byte
[
64
];
int
read
=
-
1
;
read
=
def.Read(buff,
0
, buff.Length);
while
(read
>
0
) {
output.Write(buff,
0
, read);
read
=
def.Read(buff,
0
, buff.Length);
}
def.Close();
return
output.ToArray();
}
}
}
}
public
static
T Decompress
<
T
>
(
this
byte
[] compressedData)
where
T :
class
{
return
compressedData.Decompress().Deserialize
<
T
>
();
}
public
static
T Deserialize
<
T
>
(
this
byte
[] data)
where
T :
class
{
var formatter
=
new
BinaryFormatter();
using
(MemoryStream ms
=
new
MemoryStream(data))
return
formatter.Deserialize(ms)
as
T;
}
public
static
bool
IsInArray(
this
string
[] stringArray,
string
strSearch,
bool
caseInsensetive) {
return
stringArray.GetInArrayID(strSearch, caseInsensetive)
>=
0
;
}
public
static
bool
IsInArray(
this
string
[] stringarray,
string
str) {
return
stringarray.IsInArray(str,
false
);
}
public
static
bool
IsInIPArray(
this
string
[] iparray,
string
ip) {
string
[] userip
=
ip.Split(
@"
.
"
);
for
(
int
ipIndex
=
0
; ipIndex
<
iparray.Length; ipIndex
++
) {
string
[] tmpip
=
iparray[ipIndex].Split(
@"
.
"
);
int
r
=
0
;
for
(
int
i
=
0
; i
<
tmpip.Length; i
++
) {
if
(tmpip[i]
==
"
*
"
)
return
true
;
if
(userip.Length
>
i) {
if
(tmpip[i]
==
userip[i]) r
++
;
else
break
;
}
else
break
;
}
if
(r
==
4
)
return
true
;
}
return
false
;
}
//
Action<string, int> MsgW3 = (s, i) => { Msg.Write(s + i); Msg.Write("<br />"); };
//
"test1,test2,test3".Split(',').Action<string>(MsgW3);
}
}