Delphi泛型动态数组的扩展--转贴
此文章转载于http://www.raysoftware.cn/?p=278&tdsourcetag=s_pcqq_aiomsg的博客
从Delphi支持泛型的第一天起就有了一种新的动态数组类型,泛型化的动态数组–TArray.
虽然这个类型比较方便,但是却没有提供更丰富的操作.因为XE4中提供了对数据类型的Helper扩展,例如StringHelper,企图实现一个TArrayHelper但是发现Helper不支持泛型的类型.
没办法只好包装了一个record,好处是似乎只要支持泛型的Delphi版本都可以支持.使用Demo如下：
procedure TestTArrayEx;
var
a, b, c: TArrayEx<Integer>;
f: TArrayEx<Single>;
s : TArrayEx<string>;
//
i: Integer;
z: array of Integer;
args:TArrayEx<string>;
begin
// assign a := [2, 2, 3, 4];
s := ['haha', 'hello']; // clone
b := a.Clone; // 给元素赋值
b[0] := 5; // operator +
c := a + b; c := 88 + c + 99;
a.Append([10, 20, 30]);
a.Insert(2, 1000);
a.Insert(2, [1000, 45]); a[0] := 7; // Unique
c.Unique;
// Delete
c.Delete(0, 3); // compare
if c = z then
// for in loop
for i in c do
if i = 0 then
begin
//
end; //
f := [1, 2, 3.1415926];
f.Size := 200;
if f[0] = 1.2 then
begin
f.Size := 100;
end;
end;
这些成员方法和操作符重载都是原来的TArray所不具备的.注重开发效率可以用这个办法封装一些类型,简化操作.
TArrayEx的实现代码在下面.记得必须是支持泛型版本的Delphi哦,也就是至少要Delphi2009版以后的.
unit TJArrayEx;
{ ******************************************************************************
泛型动态数组的扩展.
sample:
var
a, b, c: TArrayEx<Integer>;
f: TArrayEx<Single>;
s : TArrayEx<string>;
//
i: Integer;
z: array of Integer;
args:TArrayEx<string>;
begin
// assign
a := [2, 2, 3, 4];
s := ['haha', 'hello'];
// clone
b := a.Clone;
// 给元素赋值
b[0] := 5;
// operator +
c := a + b;
c := 88 + c + 99;
a.Append([10, 20, 30]);
a.Insert(2, 1000);
a.Insert(2, [1000, 45]);
a[0] := 7;
// Unique
c.Unique;
// Delete
c.Delete(0, 3);
// compare
if c = z then
// for in loop
for i in c do
if i = 0 then
begin
//
end;
//
f := [1, 2, 3.1415926];
f.Size := 200;
if f[0] = 1.0 then
begin
end;
args := ['38inch','45inch','XL','XL2','X','38inch','45inch'];
args.Unique;
//sort
args.Sort;
//search
if args.BinarySearch('XL',i) then
ShowMessageFmt('foud index:%d',[i]);
end;
****************************************************************************** }
interface
uses System.Generics.Defaults, System.SysUtils;
type
TArrayEx<T> = record
strict private
type
TEnumerator = class
private
FValue: TArray<T>;
FIndex: NativeInt;
function GetCurrent: T;
public
constructor Create(const AValue: TArray<T>);
function MoveNext: Boolean;
property Current: T read GetCurrent;
end;
public
function GetEnumerator(): TEnumerator;
strict private
FData: TArray<T>;
function GetRawData: TArray<T>;
function GetElements(Index: Integer): T;
procedure SetElements(Index: Integer; const Value: T);
private
class function EqualArray(A, B: TArray<T>): Boolean; static;
class function CompareT(const A, B: T): Boolean; static;
class procedure CopyArray(var FromArray, ToArray: TArray<T>;
FromIndex: NativeInt = 0; ToIndex: NativeInt = 0;
Count: NativeInt = -1); static;
class procedure MoveArray(var AArray: array of T;
FromIndex, ToIndex, Count: Integer); static;
class function DynArrayToTArray(const Value: array of T): TArray<T>; static;
class function Min(A, B: NativeInt): NativeInt; static;
procedure QuickSort(const Comparer: IComparer<T>; L, R: Integer);
public // operators
class operator Implicit(Value: TArray<T>): TArrayEx<T>; overload;
class operator Implicit(Value: array of T): TArrayEx<T>; overload;
(*
这个无解,Delphi不允许array of T作为返回值.也就是这个转换是被废了.只好用AssignTo
class operator Implicit(Value: TArrayEx<T>):array of T; overload;
*)
class operator Implicit(Value: TArrayEx<T>): TArray<T>; overload;
class operator Explicit(Value: TArrayEx<T>): TArray<T>; overload;
class operator Explicit(Value: array of T): TArrayEx<T>; overload;
class operator Add(A, B: TArrayEx<T>): TArrayEx<T>; overload;
class operator Add(A: TArrayEx<T>; const B: T): TArrayEx<T>; overload;
class operator Add(const A: T; B: TArrayEx<T>): TArrayEx<T>; overload;
class operator Add(A: TArrayEx<T>; B: array of T): TArrayEx<T>; overload;
class operator Add(A: array of T; B: TArrayEx<T>): TArrayEx<T>; overload;
class operator In (A: T; B: TArrayEx<T>): Boolean; overload;
//
class operator Equal(A, B: TArrayEx<T>): Boolean; overload;
class operator Equal(A: TArrayEx<T>; B: TArray<T>): Boolean; overload;
class operator Equal(A: TArray<T>; B: TArrayEx<T>): Boolean; overload;
class operator Equal(A: array of T; B: TArrayEx<T>): Boolean; overload;
class operator Equal(A: TArrayEx<T>; B: array of T): Boolean; overload;
public
procedure SetLen(Value: NativeInt); inline;
function GetLen: NativeInt; inline;
function ByteLen: NativeInt; inline;
class function Create(Value: array of T): TArrayEx<T>; overload; static;
class function Create(Value: TArrayEx<T>): TArrayEx<T>; overload; static;
class function Create(const Value: T): TArrayEx<T>; overload; static;
function Clone(): TArrayEx<T>;
procedure SetValue(Value: array of T);
function ToArray(): TArray<T>;
function SubArray(AFrom, ACount: NativeInt): TArrayEx<T>;
procedure Delete(AFrom, ACount: NativeInt); overload;
procedure Delete(AIndex: NativeInt); overload;
procedure Append(Values: TArrayEx<T>); overload;
procedure Append(const Value: T); overload;
procedure Append(Values: array of T); overload;
procedure Append(Values: TArray<T>); overload;
function Insert(AIndex: NativeInt; const Value: T): NativeInt; overload;
function Insert(AIndex: NativeInt; const Values: array of T)
: NativeInt; overload;
function Insert(AIndex: NativeInt; const Values: TArray<T>)
: NativeInt; overload;
function Insert(AIndex: NativeInt; const Values: TArrayEx<T>)
: NativeInt; overload;
procedure Unique();
// 排序
procedure Sort(); overload;
procedure Sort(const Comparer: IComparer<T>); overload;
procedure Sort(const Comparer: IComparer<T>;
Index, Count: Integer); overload;
// 搜索
function BinarySearch(const Item: T; out FoundIndex: Integer;
const Comparer: IComparer<T>; Index, Count: Integer): Boolean; overload;
function BinarySearch(const Item: T; out FoundIndex: Integer;
const Comparer: IComparer<T>): Boolean; overload;
function BinarySearch(const Item: T; out FoundIndex: Integer)
: Boolean; overload;
property Size: NativeInt read GetLen write SetLen;
property Len: NativeInt read GetLen write SetLen;
property RawData: TArray<T> read GetRawData;
property Elements[Index: Integer]: T read GetElements
write SetElements; default;
end;
implementation
uses System.RTLConsts;
class operator TArrayEx<T>.Add(A, B: TArrayEx<T>): TArrayEx<T>;
begin
Result := A.Clone;
Result.Append(B);
end;
class operator TArrayEx<T>.Add(A: TArrayEx<T>; const B: T): TArrayEx<T>;
begin
Result := A.Clone;
Result.Append(B);
end;
class operator TArrayEx<T>.Add(const A: T; B: TArrayEx<T>): TArrayEx<T>;
begin
Result.SetValue([A]);
Result.Append(B);
end;
class operator TArrayEx<T>.Add(A: TArrayEx<T>; B: array of T): TArrayEx<T>;
begin
Result := A.Clone;
Result.Append(B);
end;
class operator TArrayEx<T>.Add(A: array of T; B: TArrayEx<T>): TArrayEx<T>;
begin
Result.FData := DynArrayToTArray(A);
Result.Append(B);
end;
class operator TArrayEx<T>.In(A: T; B: TArrayEx<T>): Boolean;
var
Tmp: T;
begin
Result := False;
for Tmp in B.FData do
if CompareT(A, Tmp) then
begin
Result := True;
Break;
end;
end;
class operator TArrayEx<T>.Equal(A, B: TArrayEx<T>): Boolean;
begin
Result := EqualArray(A.FData, B.FData);
end;
class operator TArrayEx<T>.Equal(A: TArrayEx<T>; B: TArray<T>): Boolean;
begin
Result := EqualArray(A.FData, B);
end;
class operator TArrayEx<T>.Equal(A: TArray<T>; B: TArrayEx<T>): Boolean;
begin
Result := EqualArray(A, B.FData);
end;
class operator TArrayEx<T>.Equal(A: array of T; B: TArrayEx<T>): Boolean;
begin
Result := EqualArray(DynArrayToTArray(A), B.FData);
end;
class operator TArrayEx<T>.Equal(A: TArrayEx<T>; B: array of T): Boolean;
begin
Result := EqualArray(A.FData, DynArrayToTArray(B));
end;
function TArrayEx<T>.BinarySearch(const Item: T; out FoundIndex: Integer;
const Comparer: IComparer<T>; Index, Count: Integer): Boolean;
var
L, H: Integer;
mid, cmp: Integer;
begin
if (Index < Low(FData)) or ((Index > High(FData)) and (Count > 0)) or
(Index + Count - 1 > High(FData)) or (Count < 0) or (Index + Count < 0) then
raise EArgumentOutOfRangeException.CreateRes(@SArgumentOutOfRange);
if Count = 0 then
begin
FoundIndex := Index;
Exit(False);
end;
Result := False;
L := Index;
H := Index + Count - 1;
while L <= H do
begin
mid := L + (H - L) shr 1;
cmp := Comparer.Compare(FData[mid], Item);
if cmp < 0 then
L := mid + 1
else
begin
H := mid - 1;
if cmp = 0 then
Result := True;
end;
end;
FoundIndex := L;
end;
function TArrayEx<T>.BinarySearch(const Item: T; out FoundIndex: Integer;
const Comparer: IComparer<T>): Boolean;
begin
Result := BinarySearch(Item, FoundIndex, Comparer, Low(FData), Length(FData));
end;
function TArrayEx<T>.BinarySearch(const Item: T;
out FoundIndex: Integer): Boolean;
begin
Result := BinarySearch(Item, FoundIndex, TComparer<T>.Default, Low(FData),
Length(FData));
end;
function TArrayEx<T>.ByteLen: NativeInt;
begin
Result := Length(FData) * Sizeof(T);
end;
class function TArrayEx<T>.Min(A, B: NativeInt): NativeInt;
begin
Result := A;
if Result > B then
Result := B;
end;
class procedure TArrayEx<T>.CopyArray(var FromArray, ToArray: TArray<T>;
FromIndex, ToIndex, Count: NativeInt);
var
i: Integer;
begin
if Count = 0 then
Exit;
if Count < 0 then
Count := Min(Length(FromArray), Length(ToArray));
if Length(FromArray) < (FromIndex + Count) then
Count := Length(FromArray) - FromIndex;
if Length(ToArray) < (ToIndex + Count) then
Count := Length(ToArray) - ToIndex;
if Count > 0 then
for i := 0 to Count - 1 do
ToArray[ToIndex + i] := FromArray[FromIndex + i];
end;
class procedure TArrayEx<T>.MoveArray(var AArray: array of T;
FromIndex, ToIndex, Count: Integer);
var
i: Integer;
begin
if Count > 0 then
begin
if FromIndex < ToIndex then
for i := Count - 1 downto 0 do
AArray[ToIndex + i] := AArray[FromIndex + i]
else if FromIndex > ToIndex then
for i := 0 to Count - 1 do
AArray[ToIndex + i] := AArray[FromIndex + i];
end;
end;
procedure TArrayEx<T>.QuickSort(const Comparer: IComparer<T>; L, R: Integer);
var
i, J: Integer;
pivot, temp: T;
begin
if (Length(FData) = 0) or ((R - L) <= 0) then
Exit;
repeat
i := L;
J := R;
pivot := FData[L + (R - L) shr 1];
repeat
while Comparer.Compare(FData[i], pivot) < 0 do
Inc(i);
while Comparer.Compare(FData[J], pivot) > 0 do
Dec(J);
if i <= J then
begin
if i <> J then
begin
temp := FData[i];
FData[i] := FData[J];
FData[J] := temp;
end;
Inc(i);
Dec(J);
end;
until i > J;
if L < J then
QuickSort(Comparer, L, J);
L := i;
until i >= R;
end;
class function TArrayEx<T>.DynArrayToTArray(const Value: array of T): TArray<T>;
var
i: Integer;
begin
SetLength(Result, Length(Value));
for i := Low(Value) to High(Value) do
Result[i] := Value[i];
end;
class function TArrayEx<T>.EqualArray(A, B: TArray<T>): Boolean;
var
i: Integer;
begin
Result := True;
if A = B then
Exit;
if Length(A) <> Length(B) then
begin
Result := False;
end
else
begin
for i := Low(A) to High(A) do
if not CompareT(A[i], B[i]) then
begin
Result := False;
Break;
end;
end;
end;
class function TArrayEx<T>.CompareT(const A, B: T): Boolean;
var
Compare: IComparer<T>;
begin
Compare := TComparer<T>.Default;
Result := Compare.Compare(A, B) = 0;
end;
// class function TArrayEx<T>.CompareT(const A, B: T): Boolean;
// var
// p1, p2: PByte;
// i: Integer;
// begin
// Result := True;
// p1 := PByte(@A);
// p2 := PByte(@B);
// for i := 0 to Sizeof(T) - 1 do
// begin
// //
// if p1^ <> p2^ then
// begin
// Result := False;
// Exit;
// end;
// Inc(p1);
// Inc(p2);
// end;
// end;
function TArrayEx<T>.GetElements(Index: Integer): T;
begin
Result := FData[Index];
end;
function TArrayEx<T>.GetEnumerator: TEnumerator;
begin
Result := TEnumerator.Create(FData);
end;
function TArrayEx<T>.GetLen: NativeInt;
begin
Result := Length(FData);
end;
function TArrayEx<T>.GetRawData: TArray<T>;
begin
Result := FData;
end;
class operator TArrayEx<T>.Implicit(Value: TArrayEx<T>): TArray<T>;
begin
SetLength(Result, Length(Value.FData));
CopyArray(Value.FData, Result, 0, 0, Length(Value.FData));
end;
class operator TArrayEx<T>.Explicit(Value: array of T): TArrayEx<T>;
begin
Result.SetValue(Value);
end;
class operator TArrayEx<T>.Implicit(Value: array of T): TArrayEx<T>;
begin
Result.SetValue(Value);
end;
class operator TArrayEx<T>.Implicit(Value: TArray<T>): TArrayEx<T>;
begin
SetLength(Result.FData, Length(Value));
CopyArray(Value, Result.FData, 0, 0, Length(Value));
end;
class operator TArrayEx<T>.Explicit(Value: TArrayEx<T>): TArray<T>;
begin
SetLength(Result, Length(Value.FData));
CopyArray(Value.FData, Result, 0, 0, Length(Value.FData));
end;
procedure TArrayEx<T>.SetElements(Index: Integer; const Value: T);
begin
FData[Index] := Value;
end;
procedure TArrayEx<T>.SetLen(Value: NativeInt);
begin
SetLength(FData, Value);
end;
procedure TArrayEx<T>.SetValue(Value: array of T);
begin
FData := DynArrayToTArray(Value);
end;
procedure TArrayEx<T>.Sort;
begin
QuickSort(TComparer<T>.Default, Low(FData), High(FData));
end;
procedure TArrayEx<T>.Sort(const Comparer: IComparer<T>; Index, Count: Integer);
begin
if (Index < Low(FData)) or ((Index > High(FData)) and (Count > 0)) or
(Index + Count - 1 > High(FData)) or (Count < 0) or (Index + Count < 0) then
raise EArgumentOutOfRangeException.CreateRes(@SArgumentOutOfRange);
if Count <= 1 then
Exit;
QuickSort(Comparer, Index, Index + Count - 1);
end;
procedure TArrayEx<T>.Sort(const Comparer: IComparer<T>);
begin
QuickSort(Comparer, Low(FData), High(FData));
end;
function TArrayEx<T>.ToArray(): TArray<T>;
begin
SetLength(Result, Length(FData));
CopyArray(FData, Result, 0, 0, Length(FData));
end;
class function TArrayEx<T>.Create(Value: array of T): TArrayEx<T>;
begin
Result.SetValue(Value);
end;
class function TArrayEx<T>.Create(Value: TArrayEx<T>): TArrayEx<T>;
begin
Result := Value.Clone;
end;
class function TArrayEx<T>.Create(const Value: T): TArrayEx<T>;
begin
Result.SetValue([Value]);
end;
function TArrayEx<T>.Clone(): TArrayEx<T>;
begin
Result := SubArray(0, Length(FData));
end;
function TArrayEx<T>.SubArray(AFrom, ACount: NativeInt): TArrayEx<T>;
begin
SetLength(Result.FData, ACount);
CopyArray(FData, Result.FData, AFrom, 0, ACount);
end;
procedure TArrayEx<T>.Delete(AFrom, ACount: NativeInt);
begin
if AFrom >= Length(FData) then
Exit;
if (AFrom + ACount) > Length(FData) then
ACount := Length(FData) - AFrom;
MoveArray(FData, AFrom + ACount, AFrom, Length(FData) - (AFrom + ACount));
SetLength(FData, Length(FData) - ACount);
end;
procedure TArrayEx<T>.Delete(AIndex: NativeInt);
begin
Delete(AIndex, 1);
end;
procedure TArrayEx<T>.Append(Values: TArrayEx<T>);
begin
Insert(Length(FData), Values);
end;
procedure TArrayEx<T>.Append(Values: TArray<T>);
begin
Insert(Length(FData), Values);
end;
procedure TArrayEx<T>.Append(const Value: T);
begin
SetLength(FData, Length(FData) + 1);
FData[High(FData)] := Value;
end;
procedure TArrayEx<T>.Append(Values: array of T);
begin
Insert(Length(FData), Values);
end;
function TArrayEx<T>.Insert(AIndex: NativeInt; const Value: T): NativeInt;
var
i: Integer;
begin
Result := -1;
if (AIndex > Length(FData)) or (AIndex < 0) then
Exit;
SetLength(FData, Length(FData) + 1);
MoveArray(FData, AIndex, AIndex + 1, Length(FData) - AIndex);
FData[AIndex] := Value;
Result := AIndex;
end;
function TArrayEx<T>.Insert(AIndex: NativeInt; const Values: array of T)
: NativeInt;
var
i: Integer;
begin
SetLength(FData, Length(FData) +Length(Values));
MoveArray(FData, AIndex, AIndex + Length(Values), Length(FData) - AIndex);
for i := 0 to Length(Values) - 1 do
FData[AIndex + i] := Values[i];
Result := AIndex;
end;
function TArrayEx<T>.Insert(AIndex: NativeInt; const Values: TArray<T>)
: NativeInt;
var
i: Integer;
begin
SetLength(FData, Length(FData) + Length(Values));
MoveArray(FData, AIndex, AIndex + Length(Values), Length(FData) - AIndex);
for i := 0 to Length(Values) - 1 do
FData[AIndex + i] := Values[i];
Result := AIndex;
end;
function TArrayEx<T>.Insert(AIndex: NativeInt; const Values: TArrayEx<T>)
: NativeInt;
begin
Result := Insert(AIndex, Values.ToArray);
end;
procedure TArrayEx<T>.Unique();
var
i, J: Integer;
Tmp: TArrayEx<T>;
Flag: Boolean;
begin
for i := High(FData) downto Low(FData) do
begin
Flag := False;
for J := High(Tmp.FData) downto Low(Tmp.FData) do
begin
if CompareT(FData[i], Tmp[J]) then
begin
Flag := True;
Break;
end;
end;
if not Flag then
Tmp.Append(FData[i]);
end;
FData := Tmp.FData;
end;
{ TArrayEx<T>.TEnumerator }
constructor TArrayEx<T>.TEnumerator.Create(const AValue: TArray<T>);
begin
FValue := AValue;
FIndex := -1;
end;
function TArrayEx<T>.TEnumerator.GetCurrent: T;
begin
Result := FValue[FIndex];
end;
function TArrayEx<T>.TEnumerator.MoveNext: Boolean;
begin
Result := False;
if (FIndex >= Length(FValue)) then
Exit;
Inc(FIndex);
Result := FIndex < Length(FValue);
end;
end.
Delphi泛型动态数组的扩展--转贴的更多相关文章
- Delphi 的动态数组
传统的Pascal 语言其数组大小是预先确定的,当你用数组结构声明数据类型时,你必须指定数组元素的个数.专业程序员也许知道些许动态数组的实现技术,一般是采用指针,用手工分配并释放所需的内存. Delp ...
- [转]delphi 删除动态数组的指定元素
type TArr = array of TPoint; {把数组先定义成一个类型会方便许多, 这里仅用 TPoint 测试} {删除动态数组指定元素的过程: 参数 arr 是数组名, 参数 Inde ...
- delphi动态数组指针问题
就一个button事件 procedure TForm1.btn7Click(Sender: TObject); Type TMyArr = array of array of array of In ...
- 扩展 delphi 泛型 以实现类似lambda功能 , C#中的any count first last 等扩展方法
扩展 delphi 泛型 以实现类似lambda功能 , C#中的any count first last 等扩展方法 在C#中对泛型的扩展,输入参数是泛型本身的内容,返回值则是bool.基于这一点, ...
- Delphi内存管理（Integer、Boolean、Record、枚举等都是在作用域内编译器自动申请内存，出了作用域自动释放；另外，字符串、Variant、动态数组、接口也是由Delphi自动管理）
一.什么是堆.栈? 程序需要的内存空间分为 heap(堆) 和 stack(栈),heap 是自由存储区, stack 是自动存储区,使用 heap 需要手动申请.手动释放, stack 是自动申请. ...
- delphi 静态3维数组。 严重占用堆栈 切记。 应该用动态数组， 非要用静态数组的话， 要在编译器里 把 堆栈 调大
delphi 代码正确, 但是运行就崩溃. 原因为 定义了 一些 静态3维数组. 应该扩大 软件的 堆栈 设置. 然后正常解决问题 静态3维数组. 严重占用堆栈 切记. 应该用动态 ...
- 一篇文章让你了解动态数组的数据结构的实现过程（Java 实现）
目录 数组基础简单回顾 二次封装数组类设计 基本设计 向数组中添加元素 在数组中查询元素和修改元素 数组中的包含.搜索和删除元素 使用泛型使该类更加通用(能够存放 "任意" 数据类 ...
- [数据结构1.2-线性表] 动态数组ArrayList（.NET源码学习）
[数据结构1.2-线性表] 动态数组ArrayList(.NET源码学习) 在C#中,存在常见的九种集合类型:动态数组ArrayList.列表List.排序列表SortedList.哈希表HashTa ...
- 常用数据结构-线性表及Java 动态数组 深究
[Java心得总结六]Java容器中——Collection在前面自己总结的一篇博文中对Collection的框架结构做了整理,这里深究一下Java中list的实现方式 1.动态数组 In compu ...
随机推荐
- 大数据量报表APPLET打印分页传输方案
1 . 问题概述 当报表运算完成时,客户端经常需要调用润乾自带的runqianReport4Applet.jar来完成打印操作, 然而数据量比较大的时候,会导致无法加载完成,直至applet内存 ...
- ASP.NET MVC 实现区域 项目分离 (比较好的方式)
说明: ZRT.Web 是前台网站,目录[D:\ZRT.Web\] ZRT.Admin 是后台管理,目录[D:\ZRT.Web\Applications\Admin\],删除文件[Global.asa ...
- 7.log4j2的使用
一.简介 log4j2相对于log4j 1.x有了脱胎换骨的变化,其官网宣称的优势有多线程下10几倍于log4j 1.x和logback的高吞吐量.可配置的审计型日志.基于插件架构的各种灵活配置等.如 ...
- springMVC入门-08
这一讲介绍用户登录实现以及两种异常处理controller控制器的方法,最后提一下在springMVC中对静态资源访问的实现方法. 用户登录需要一个登录页面login.jsp,对应代码如下所示: &l ...
- 使用ASP.Net WebAPI构建REST服务——客户端
原文的链接:http://www.cnblogs.com/TianFang/p/3724449.html WebAPI是标准的Http协议,支持Http协议的客户端(如浏览器)都可以访问.但是,有的时 ...
- c# 托管和非托管的介绍
在.net 编程环境中,系统的资源分为托管资源和非托管资源. 对于托管的资源的回收工作,是不需要人工干预回收的,而且你也无法干预他们的回收,所能够做的 只是了解.net CLR如何做这些操作.也就是说 ...
- 生成器（generator），迭代器（yield）
g=(i for i in range(10)) #小括号表示生成一个迭代生成器.[]是列表生成器 g.__next__() yield将一个函数变成生成器 import time def f(): ...
- php面试宝典
1.表单中 get与post提交方法的区别? 答:get是发送请求HTTP协议通过url参数传递进行接收,而post是实体数据,可以通过表单提交大量信息. 2.session与cookie的区别? 答 ...
- win10WLAN没有有效的ip配置
方案一:将路由器和猫重启一下,一般都可以解决了!方案二:1.在开始菜单上单击鼠标右键,选择“命令提示符(管理员)”,如果没有找到这个选项,通过cortana搜索cmd,右键以管理员身份运行,还可以进入 ...
- Ubuntu 配置Mysql远程连接
首先安装mysql.mysqlclient sudo apt-get install mysql-server mysql-clientsudo apt-get install libmysqlcli ...