;
...
#end
}
```
---
### Author:  [@haxecoder](https://community.haxe.org/u/haxecoder)
#### Post date: [November 27, 2023, 8:48am UTC](https://community.haxe.org/t/how-to-compile-a-native-array-for-c-target/4092/2 "2023-11-27T08:48:51Z")
So the problem is the conditional compilation flag and you are trying to avoid that?
---
### Author:  [@ibilon](https://community.haxe.org/u/ibilon)
#### Post date: [November 27, 2023, 9:18am UTC](https://community.haxe.org/t/how-to-compile-a-native-array-for-c-target/4092/3 "2023-11-27T09:18:23Z")
You can use a typedef:
```haxe
#if cs
import cs.NativeArray;
#else
typedef NativeArray = Array;
#end
```
and then you can use the name `NativeArray` in all targets.
What’s your use case? A native array will not behave exactly the same as a Haxe array.
---
### Author:  [@witcher](https://community.haxe.org/u/witcher)
#### Post date: [November 27, 2023, 10:32am UTC](https://community.haxe.org/t/how-to-compile-a-native-array-for-c-target/4092/4 "2023-11-27T10:32:57Z")
Correct. Looks like I should cast it into one type.
---
### Author:  [@witcher](https://community.haxe.org/u/witcher)
#### Post date: [November 27, 2023, 10:54am UTC](https://community.haxe.org/t/how-to-compile-a-native-array-for-c-target/4092/5 "2023-11-27T10:54:04Z")
Great. However, I still can’t use Lambda because NA is not Iterable. I don’t know how to get iterator from NA. But that’s no longer an issue, I just can use ‘for’ instead. My case is shared logic between two platforms, iterating array, adding elements. So it might be better to use List\_1 instead of NativeArray
> #if cs
> import cs.system.collections.generic.List\_1;
> #else
> typedef List\_1 = Array;
> #end
---
### Author:  [@ibilon](https://community.haxe.org/u/ibilon)
#### Post date: [November 27, 2023, 11:01am UTC](https://community.haxe.org/t/how-to-compile-a-native-array-for-c-target/4092/6 "2023-11-27T11:01:46Z")
But Array is available on the c# target, why do you specifically want a native array?
Using the same Array type will allow you to share logic more easily, since they’d have the same behavior.
---
### Author:  [@witcher](https://community.haxe.org/u/witcher)
#### Post date: [November 27, 2023, 11:08am UTC](https://community.haxe.org/t/how-to-compile-a-native-array-for-c-target/4092/7 "2023-11-27T11:08:26Z")
Most part of the code is already done on the native target, I wouldn’t change it. And I would like to use native data types to avoid any platform (Unity) compatibility problems now and in the future.
---
### Author:  [@aartzrc](https://community.haxe.org/u/aartzrc)
#### Post date: [November 28, 2023, 1:33am UTC](https://community.haxe.org/t/how-to-compile-a-native-array-for-c-target/4092/8 "2023-11-28T01:33:11Z")
Here’s some code we use to iterate on native CS arrays inside Haxe, hopefully they can get you a step further. They’re extension methods so do `using CSTools`.
```haxe
#if cs
import cs.system.collections.generic.List_1;
class CSTools {
public static function iterator(hashSet:cs.system.collections.generic.IEnumerable_1):Iterator {
return new IEnumerableIterator(hashSet);
}
public static function toNative(array:Array):cs.NativeArray {
var nativeArray = new cs.NativeArray(array.length);
for(i in 0 ... array.length) nativeArray[i]=array[i];
return nativeArray;
}
public inline static function toNativeList(array:Array):List_1 {
var nativeList = new List_1(array.length);
for(i in array) nativeList.Add(i);
return nativeList;
}
}
class IEnumerableIterator {
var enumerator:cs.system.collections.generic.IEnumerator_1;
var hasNextBool = false;
var nextCalled = false;
public function new(enumerable:cs.system.collections.generic.IEnumerable_1) {
enumerator = enumerable.GetEnumerator();
}
public function hasNext():Bool {
if(!nextCalled) {
hasNextBool = enumerator.MoveNext();
nextCalled = true;
}
return hasNextBool;
}
public function next():T {
hasNext();
nextCalled = false;
return enumerator.Current;
}
}
#end
```
Usage looks like this:
```haxe
var intArray = [1, 2, 3, 4]; // Haxe Array
var csArray = intArray.toNative(); // Converted to C# Array
for(i in csArray) trace(i); // Iterate over C# Array
```
---
### Author:  [@witcher](https://community.haxe.org/u/witcher)
#### Post date: [November 28, 2023, 12:45pm UTC](https://community.haxe.org/t/how-to-compile-a-native-array-for-c-target/4092/9 "2023-11-28T12:45:35Z")
Thank for iterator. I supplemented your code collection:
```haxe
#if js
typedef NativeArray = Array;
typedef List_1 = Array;
typedef Dictionary_2 = Map;
#end
class CSTools {
public static function iterator(hashSet:cs.system.collections.generic.IEnumerable_1):Iterator {
return new IEnumerableIterator(hashSet);
}
@:generic public static function push(_this:cs.system.collections.generic.List_1, x:T):Int {
_this.Add(x);
return _this.Count;
}
public static function pop(_this:cs.system.collections.generic.List_1):T {
var i:T = _this[0];
_this.RemoveAt(0);
return i;
}
public static function sort(_this:cs.system.collections.generic.List_1, f:T->T->Int):Void {
_this.Sort(f);
}
@:generic public static function get(_this:cs.system.collections.generic.Dictionary_2, key:K):T {
return _this.get_Item(key);
}
@:generic public static function set(_this:cs.system.collections.generic.Dictionary_2, key:K, value:T):Void {
return _this.set_Item(key, value);
}
@:generic public static function remove(_this:cs.system.collections.generic.Dictionary_2, key:K):Bool {
return _this.Remove(key);
}
}
```
so now we can use these in haxe code like
```haxe
var deck:List_1 = profile.Deck;
var next:Int = request.Value;
deck.push(next);
var events:Dictionary_2 = profile.Events;
events.get(request.Hash);
```
Using your toNative is bad practice,you’re creating a new copy array instead of make an interface with the current data. so, for example, on a server platform, with a large initial array, this isn’t applicable.
---
### Author:  [@ibilon](https://community.haxe.org/u/ibilon)
#### Post date: [November 28, 2023, 12:56pm UTC](https://community.haxe.org/t/how-to-compile-a-native-array-for-c-target/4092/10 "2023-11-28T12:56:32Z")
An alternative to a set of extension methods is making an abstract [Abstract - Haxe - The Cross-platform Toolkit](https://haxe.org/manual/types-abstract.html), that way you don’t have to add an import every time.