namespaceUniNativeLinq{publicreadonlyunsafestructNativeEnumerable<T>whereT:unmanaged{publicreadonlyT*Ptr;publicreadonlylongLength;publicNativeEnumerable(T*ptr,longlength){if(ptr==default||length<=0){Ptr=default;Length=default;return;}Ptr=ptr;Length=length;}publicrefTthis[longindex]=>refPtr[index];}}

<ProjectSdk="Microsoft.NET.Sdk"><PropertyGroup><TargetFramework>netstandard2.0</TargetFramework><RootNamespace>UniNativeLinq</RootNamespace><AllowUnsafeBlocks>True</AllowUnsafeBlocks><LangVersion>8</LangVersion><AssemblyName>UniNativeLinq</AssemblyName></PropertyGroup><ItemGroup><ReferenceInclude="UnityEngine.CoreModule"><HintPath>○Unityのインストールしてあるフォルダ○\Editor\Data\Managed\UnityEngine\UnityEngine.CoreModule.dll</HintPath></Reference></ItemGroup><TargetName="PostBuild"AfterTargets="PostBuildEvent"><ExecCommand="copy $(TargetPath) $(ProjectDir)..\Assets\Plugins\UNL\UniNativeLinq.dll"/></Target></Project>

usingNUnit.Framework;usingUniNativeLinq;usingUnity.Collections;usingUnity.Collections.LowLevel.Unsafe;namespaceTests{publicsealedunsafeclassNativeEnumerableTestScript{[Test]publicvoidDefaultValuePass(){NativeEnumerable<int>nativeEnumerable=default;Assert.AreEqual(0L,nativeEnumerable.Length);Assert.IsTrue(nativeEnumerable.Ptr==null);}[TestCase(0L)][TestCase(-10L)][TestCase(-12241L)][TestCase(long.MinValue)]publicvoidZeroOrNegativeCountTest(longcount){using(vararray=newNativeArray<int>(1,Allocator.Persistent)){Assert.IsFalse(array.GetUnsafePtr()==null);varnativeEnumerable=newNativeEnumerable<int>((int*)array.GetUnsafePtr(),count);Assert.AreEqual(0L,nativeEnumerable.Length);Assert.IsTrue(nativeEnumerable.Ptr==null);}}[TestCase(0,Allocator.Temp)][TestCase(1,Allocator.Temp)][TestCase(10,Allocator.Temp)][TestCase(114,Allocator.Temp)][TestCase(0,Allocator.TempJob)][TestCase(1,Allocator.TempJob)][TestCase(10,Allocator.TempJob)][TestCase(114,Allocator.TempJob)][TestCase(0,Allocator.Persistent)][TestCase(1,Allocator.Persistent)][TestCase(10,Allocator.Persistent)][TestCase(114,Allocator.Persistent)]publicvoidFromNativeArrayPass(intcount,Allocatorallocator){using(vararray=newNativeArray<int>(count,allocator)){varnativeEnumerable=newNativeEnumerable<int>((int*)array.GetUnsafePtr(),array.Length);Assert.AreEqual((long)count,nativeEnumerable.Length);for(vari=0;i<nativeEnumerable.Length;i++){Assert.AreEqual(0,nativeEnumerable[i]);nativeEnumerable[i]=i;}for(vari=0;i<count;i++)Assert.AreEqual(i,array[i]);}}}}

<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><TargetFramework>netstandard2.0</TargetFramework><RootNamespace>UniNativeLinq</RootNamespace><AllowUnsafeBlocks>True</AllowUnsafeBlocks><LangVersion>8</LangVersion><AssemblyName>UniNativeLinq</AssemblyName></PropertyGroup><ItemGroup><Reference Include="UnityEngine.CoreModule"><HintPath Condition="Exists('C:\Users\conve')">C:\Users\conve\Documents\Unity\Editor\Data\Managed\UnityEngine\UnityEngine.CoreModule.dll</HintPath><HintPath Condition="Exists('/opt/Unity/Editor/Unity')">/opt/Unity/Editor/Data/Managed/UnityEngine/UnityEngine.CoreModule.dll</HintPath></Reference></ItemGroup></Project>

name:CreateReleaseon:push:branches:-developjobs:buildReleaseJob:runs-on:ubuntu-lateststrategy:matrix:unity-version:[2018.4.9f1]user-name:[pCYSl5EDgo]repository-name:[HandsOn_CSharpAdventCalendar20191201]exe:['/opt/Unity/Editor/Unity']steps:-uses:pCYSl5EDgo/setup-unity@masterwith:unity-version:${{ matrix.unity-version }}-name:License Activationrun:|echo -n "$ULF" > unity.ulf${{ matrix.exe }} -nographics -batchmode -quit -logFile -manualLicenseFile ./unity.ulf || exit 0env:ULF:${{ secrets.ulf }}-run:git clone https://github.com/${{ github.repository }}-uses:actions/setup-dotnet@v1.0.2with:dotnet-version:'3.0.101'-name:Builds DLLrun:|cd ${{ matrix.repository-name }}/core~dotnet build -c Release-name:Post Process DLLrun:|cd ${{ matrix.repository-name }}mv -f ./core~/bin/Release/netstandard2.0/UniNativeLinq.dll ./Assets/Plugins/UNL/UniNativeLinq.dll-name:Run Testrun:${{ matrix.exe }} -batchmode -nographics -projectPath ${{ matrix.repository-name }} -logFile ./log.log -runEditorTests -editorTestsResultFile ../result.xml || exit 0-run:ls -l-run:cat log.log-run:cat result.xml-uses:pCYSl5EDgo/Unity-Test-Runner-Result-XML-interpreter@masterid:interpretwith:path:result.xml-if:steps.interpret.outputs.success != 'true'run:exit 1-name:Get Versionrun:|cd ${{ matrix.repository-name }}git describe --tags 1> ../version 2> ../error || exit 0-name:Cat Erroruses:pCYSl5EDgo/cat@masterid:errorwith:path:error-if:startsWith(steps.error.outputs.text, 'fatal') != 'true'run:|cat versioncat version | awk '{ split($0, versions, "-"); split(versions[1], numbers, "."); numbers[3]=numbers[3]+1; variable=numbers[1]"."numbers[2]"."numbers[3]; print variable; }' > version_increment-if:startsWith(steps.error.outputs.text, 'fatal')run:echo -n "0.0.1" > version_increment-name:Catuses:pCYSl5EDgo/cat@masterid:versionwith:path:version_increment-name:Create Releaseid:create_releaseuses:actions/create-release@v1.0.0env:GITHUB_TOKEN:${{ secrets.GITHUB_TOKEN }}with:tag_name:${{ steps.version.outputs.text }}release_name:Release Unity${{ matrix.unity-version }} - v${{ steps.version.outputs.text }}draft:falseprerelease:false-name:Upload DLLuses:actions/upload-release-asset@v1.0.1env:GITHUB_TOKEN:${{ secrets.GITHUB_TOKEN }}with:upload_url:${{ steps.create_release.outputs.upload_url }}asset_path:${{ matrix.repository-name }}/Assets/Plugins/UNL/UniNativeLinq.dllasset_name:UniNativeLinq.dllasset_content_type:application/vnd.microsoft.portable-executable

usingSystem.Collections;usingSystem.Collections.Generic;namespaceUniNativeLinq{publicreadonlyunsafepartialstructNativeEnumerable<T>:IEnumerable<T>whereT:unmanaged{publicreadonlyT*Ptr;publicreadonlylongLength;publicNativeEnumerable(T*ptr,longlength){if(ptr==default||length<=0){Ptr=default;Length=default;return;}Ptr=ptr;Length=length;}publicrefTthis[longindex]=>refPtr[index];publicEnumeratorGetEnumerator()=>newEnumerator(this);IEnumerator<T>IEnumerable<T>.GetEnumerator()=>GetEnumerator();IEnumeratorIEnumerable.GetEnumerator()=>GetEnumerator();}}

usingSystem.Collections;usingSystem.Collections.Generic;namespaceUniNativeLinq{publicreadonlypartialstructNativeEnumerable<T>{publicunsafestructEnumerator:IEnumerator<T>{privatereadonlyT*ptr;privatereadonlylonglength;privatelongindex;publicEnumerator(NativeEnumerable<T>parent){ptr=parent.Ptr;length=parent.Length;index=-1;}publicboolMoveNext()=>++index<length;publicvoidReset()=>index=-1;publicrefTCurrent=>refptr[index];TIEnumerator<T>.Current=>Current;objectIEnumerator.Current=>Current;publicvoidDispose()=>this=default;}}}

[TestCase(0,Allocator.Temp)][TestCase(114,Allocator.Temp)][TestCase(114514,Allocator.Temp)][TestCase(0,Allocator.TempJob)][TestCase(114,Allocator.TempJob)][TestCase(114514,Allocator.TempJob)][TestCase(0,Allocator.Persistent)][TestCase(114,Allocator.Persistent)][TestCase(114514,Allocator.Persistent)]publicvoidIEnumerableTest(intcount,Allocatorallocator){using(vararray=newNativeArray<long>(count,allocator)){varnativeEnumerable=newNativeEnumerable<long>((long*)array.GetUnsafePtr(),array.Length);Assert.AreEqual(count,nativeEnumerable.Length);for(vari=0L;i<count;i++)nativeEnumerable[i]=i;varindex=0L;foreach(refvariinnativeEnumerable){Assert.AreEqual(index++,i);i=index;}index=1L;foreach(variinnativeEnumerable)Assert.AreEqual(index++,i);}}

namespaceUniNativeLinq{publicinterfaceIRefEnumerable<TEnumerator,T>:System.Collections.Generic.IEnumerable<T>whereTEnumerator:IRefEnumerator<T>{newTEnumeratorGetEnumerator();}}

namespaceUniNativeLinq{publicinterfaceIRefEnumerator<T>:System.Collections.Generic.IEnumerator<T>{newrefTCurrent{get;}}}

publicreadonlyunsafepartialstructNativeEnumerable<T>:IRefEnumerable<NativeEnumerable<T>.Enumerator,T>

publicunsafestructEnumerator:IRefEnumerator<T>

New-ItemAPI/RefAction.csNew-ItemInterface/IRefAction.csNew-ItemUtility/DelegateRefActionToStructOperatorAction.csNew-ItemUtility/Unsafe.csNew-ItemCollection/SelectEnumerable.csNew-ItemCollection/SelectEnumerable.Enumerator.cs

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.0</TargetFramework>
    <RootNamespace>_post</RootNamespace>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Mono.Cecil" Version="0.11.1" />
  </ItemGroup>
</Project>

usingSystem;usingSystem.IO;publicsealedclassProgram{staticintMain(string[]args){if(!ValidateArguments(args,outFileInfoinputUniNativeLinqDll,outFileInfooutputUniNativeLinqDllPath,outDirectoryInfounityEngineFolder)){return1;}using(DllProcessorprocessor=newDllProcessor(inputUniNativeLinqDll,outputUniNativeLinqDllPath,unityEngineFolder)){processor.Process();}return0;}privatestaticboolValidateArguments(string[]args,outFileInfoinputUniNativeLinqDll,outFileInfooutputNativeLinqDllPath,outDirectoryInfounityEngineFolder){if(args.Length!=3){Console.Error.WriteLine("Invalid argument count.");inputUniNativeLinqDll=default;outputNativeLinqDllPath=default;unityEngineFolder=default;returnfalse;}inputUniNativeLinqDll=newFileInfo(args[0]);if(!inputUniNativeLinqDll.Exists){Console.Error.WriteLine("Empty Input UniNativeLinq.dll path");outputNativeLinqDllPath=default;unityEngineFolder=default;returnfalse;}stringoutputNativeLinqDllPathString=args[1];if(string.IsNullOrWhiteSpace(outputNativeLinqDllPathString)){Console.Error.WriteLine("Empty Output UniNativeLinq.dll path");unityEngineFolder=default;outputNativeLinqDllPath=default;returnfalse;}outputNativeLinqDllPath=newFileInfo(outputNativeLinqDllPathString);unityEngineFolder=newDirectoryInfo(args[2]);if(!unityEngineFolder.Exists){Console.Error.WriteLine("Unity Engine Dll Folder does not exist");returnfalse;}returntrue;}}

usingSystem;usingSystem.IO;usingSystem.Linq;usingMono.Cecil;usingMono.Cecil.Cil;internalstructDllProcessor:IDisposable{privatereadonlyModuleDefinitionmainModule;privatereadonlyFileInfooutputDll;publicDllProcessor(FileInfoinput,FileInfooutput){mainModule=ModuleDefinition.ReadModule(input.FullName);outputDll=output;}publicvoidProcess(){ProcessEachMethod(RewriteUnsafeAsRef);mainModule.Types.Remove(mainModule.GetType("UniNativeLinq","Unsafe"));ProcessEachMethod(RewriteThrowNotImplementedException,PredicateThrowNotImplementedException);}privatevoidProcessEachMethod(Action<MethodDefinition>action,Func<TypeDefinition,bool>predicate=default){foreach(TypeDefinitiontypeDefinitioninmainModule.Types)ProcessEachMethod(action,predicate,typeDefinition);}privatevoidProcessEachMethod(Action<MethodDefinition>action,Func<TypeDefinition,bool>predicate,TypeDefinitiontypeDefinition){foreach(TypeDefinitionnestedTypeDefinitionintypeDefinition.NestedTypes)ProcessEachMethod(action,predicate,nestedTypeDefinition);if(predicateisnull||predicate(typeDefinition))foreach(MethodDefinitionmethodDefinitionintypeDefinition.Methods)action(methodDefinition);}privatevoidRewriteUnsafeAsRef(MethodDefinitionmethodDefinition){Mono.Collections.Generic.Collection<Instruction>instructions;try{instructions=methodDefinition.Body.Instructions;}catch(NullReferenceException){return;}catch{Console.WriteLine(methodDefinition.FullName);throw;}for(inti=instructions.Count-1;i>=0;i--){Instructioninstruction=instructions[i];if(instruction.OpCode.Code!=Code.Call)continue;MethodDefinitioncallMethodDefinition;try{callMethodDefinition=((MethodReference)instruction.Operand).ToDefinition();}catch{continue;}if(callMethodDefinition.Name!="AsRef"||callMethodDefinition.DeclaringType.Name!="Unsafe")continue;instructions.RemoveAt(i);}}privateboolPredicateThrowNotImplementedException(TypeDefinitiontypeDefinition){if(!typeDefinition.HasFields)returnfalse;returntypeDefinition.Fields.Any(field=>!field.IsStatic&&field.Name=="element");}privatevoidRewriteThrowNotImplementedException(MethodDefinitionmethodDefinition){if(methodDefinition.IsStatic)return;FieldReferenceelementFieldReference=methodDefinition.DeclaringType.FindField("element").MakeHostInstanceGeneric(methodDefinition.DeclaringType.GenericParameters);ILProcessorprocessor=methodDefinition.Body.GetILProcessor();Mono.Collections.Generic.Collection<Instruction>instructions=methodDefinition.Body.Instructions;for(inti=instructions.Count-1;i>=0;i--){InstructionthrowInstruction=instructions[i];if(throwInstruction.OpCode.Code!=Code.Throw)continue;InstructionnewObjInstruction=instructions[i-1];if(newObjInstruction.OpCode.Code!=Code.Newobj)continue;MethodDefinitionnewObjMethodDefinition;try{newObjMethodDefinition=((MethodReference)newObjInstruction.Operand).ToDefinition();}catch{continue;}if(newObjMethodDefinition.Name!=".ctor"||newObjMethodDefinition.DeclaringType.FullName!="System.NotImplementedException")continue;newObjInstruction.Replace(Instruction.Create(OpCodes.Ldarg_0));throwInstruction.Replace(Instruction.Create(OpCodes.Ldflda,elementFieldReference));processor.InsertAfter(throwInstruction,Instruction.Create(OpCodes.Ret));}}publicvoidDispose(){using(Streamwriter=newFileStream(outputDll.FullName,FileMode.Create,FileAccess.Write)){mainModule.Assembly.Write(writer);}mainModule.Dispose();}}

usingMono.Cecil.Cil;internalstaticclassInstructionUtility{publicstaticvoidReplace(thisInstructioninstruction,Instructionreplace)=>(instruction.OpCode,instruction.Operand)=(replace.OpCode,replace.Operand);}

usingMono.Cecil;internalstaticclassToDefinitionUtility{publicstaticTypeDefinitionToDefinition(thisTypeReferencereference)=>referenceswitch{TypeDefinitiondefinition=>definition,GenericInstanceTypegeneric=>generic.ElementType.ToDefinition(),_=>reference.Resolve(),};publicstaticMethodDefinitionToDefinition(thisMethodReferencereference)=>referenceswitch{MethodDefinitiondefinition=>definition,GenericInstanceMethodgeneric=>generic.ElementMethod.ToDefinition(),_=>reference.Resolve(),};}

usingMono.Cecil;usingSystem.Linq;usingSystem.Collections.Generic;internalstaticclassGenericInstanceUtility{publicstaticFieldReferenceFindField(thisTypeReferencetype,stringname){if(typeisTypeDefinitiondefinition)returndefinition.FindField(name);if(typeisGenericInstanceTypegenericInstanceType)returngenericInstanceType.FindField(name);vartypeDefinition=type.ToDefinition();varfieldDefinition=typeDefinition.Fields.Single(x=>x.Name==name);if(fieldDefinition.Module==type.Module)returnfieldDefinition;returntype.Module.ImportReference(fieldDefinition);}publicstaticFieldReferenceFindField(thisTypeDefinitiontype,stringname)=>type.Fields.Single(x=>x.Name==name);publicstaticFieldReferenceFindField(thisGenericInstanceTypetype,stringname){vartypeDefinition=type.ToDefinition();vardefinition=typeDefinition.Fields.Single(x=>x.Name==name);returndefinition.MakeHostInstanceGeneric(type.GenericArguments);}publicstaticFieldReferenceMakeHostInstanceGeneric(thisFieldReferenceself,IEnumerable<TypeReference>arguments)=>newFieldReference(self.Name,self.FieldType,self.DeclaringType.MakeGenericInstanceType(arguments));publicstaticGenericInstanceTypeMakeGenericInstanceType(thisTypeReferenceself,IEnumerable<TypeReference>arguments){varinstance=newGenericInstanceType(self);foreach(varargumentinarguments)instance.GenericArguments.Add(argument);returninstance;}}

usingSystem;usingUnityEditor;namespaceHandsOn{publicstaticclassUnityPackageBuilder{publicstaticvoidBuild(){string[]args=Environment.GetCommandLineArgs();stringexportPath=args[args.Length-1];AssetDatabase.ExportPackage(new[]{"Assets/Plugins/UNL/UniNativeLinq.dll"},exportPath,ExportPackageOptions.Default);}}}

-name:Create UnityPackagerun:${{ matrix.exe }} -batchmode -nographics -quit -projectPath ${{ matrix.repository-name }} -logFile ./log.log -executeMethod HandsOn.UnityPackageBuilder.Build "../UniNativeLinq.unitypackage"-run:cat log.log-name:Upload Unity Packageuses:actions/upload-release-asset@v1.0.1env:GITHUB_TOKEN:${{ secrets.GITHUB_TOKEN }}with:upload_url:${{ steps.create_release.outputs.upload_url }}asset_path:UniNativeLinq.unitypackageasset_name:UniNativeLinq.unitypackageasset_content_type:application/x-gzip