Found this excellent article that describes in detail how NAT-traversal work.
I hadn't consider the 'virtual' aspect of how we open up communication channels. It all makes sense, good thing this article was written in such a great way!
https://tailscale.com/blog/how-nat-traversal-works
I've been playing around a bit with trying to get a value typed struct with an 'array like data load' into a good state where I feel happy using it. I'll let this serve as a template for future reference to highlight what the syntax look like.
Beware that using the 'in' parameter comes with a caveat. C# treats all methods as 'maybe mutable' and hence will do a defensive copy on the referenced object prior to invoking the function.
The alternative is to use ref, but then you are cluttering the invocation.
Example usage with static anonymous function to avoid lambda allocation:
hits = new int[3];
var container = new List<int>();
range.ForeachMarkedIndexWithCount(hits, container, static (entityIndex, hits, container, i) =>
{
hits[i] = entityIndex;
container.Add(entityIndex);
});
range.CombineAndMaskWith(combine, mask);Code-snippet using unsafe struct, with fixed ulong words with constant size etc
public unsafe struct NetIndexRange {
private const int BitsPerWord = 64;
private const int NumWords = (NetConstants.NumMaxNetEntities + BitsPerWord - 1) / BitsPerWord; // Ceiling of for example : 1000/64 = 16
private fixed ulong _words[NumWords];
private ref ulong ModifyWord(int index)
{
return ref _words[index];
}
public void MarkIndex(int index)
{
int wordIndex = index / 64;
int bitPosition = index % 64;
ulong mask = 1UL << bitPosition;
ModifyWord(wordIndex) |= mask;
}
public void ClearIndex(int index)
{
int wordIndex = index / 64;
int bitPosition = index % 64;
ulong mask = ~(1UL << bitPosition);
ModifyWord(wordIndex) &= mask;
}
{
for (int wordIndex = 0; wordIndex < NumWords; ++wordIndex)
{
ulong combinedWord = _words[wordIndex] | combine._words[wordIndex];
ulong maskWord = mask._words[wordIndex];
ulong result = combinedWord & maskWord;
ModifyWord(wordIndex) = result;
}
}
where T : class
where U : class
{
int count = 0;
int entityIndex = 0;
try
{
for (int wordIndex = 0; wordIndex < NumWords; wordIndex++)
{
ulong word = ModifyWord(wordIndex);
int bitPosition = 0;
while (word != 0)
{
if ((word & 1UL) != 0)
{
entityIndex = (wordIndex * 64) + bitPosition;
eachMarkedIndexAction(entityIndex, t, u, count++);
}
word >>= 1;
bitPosition++;
}
}
}
catch (Exception e)
{
throw new Exception($"Error while invoking action on net_{entityIndex} {Environment.NewLine} OriginalException: {e}");
}
}
Scenario: someone asks for feedback on this piece of code where they want to centralize object instantiation to solve the problem. In their mind they use defensive programming to make sure we do not cause errors. The person is driven and likes to communicate.
In a team, we are asked to strive to reach consensus for how to tackle technical challenges and encourage collaboration and open discussions.
Everyones opinion carries equal weight, in discussion about the review someone on the team says that the nested if-statements makes the code hard to read and suggests that we break them into early returns instead.
Someone read an article about SOLID and suggests that it tries to tackle too many responsibilities and suggests that we break logic into standalone functions with clearer names such as TryToAddDependencyIfParent(...). Everyone on the team seems happy with contributing to making this code great.
I suggest that this code is missing the bigger picture, that we should strive to make object lifetime deterministic. That we need to be clear on errors and what happens when we don't follow the happy path.
People on the team don't understand.I phrased it wrong, it didn't get enough traction. Someone believes they understand my concern, and suggests we change the function to bool TryCreateEntity(...). The Team is happy of having built a solid solution to the problem as a group and incorporated everyones oppinion into the final solution, we have built something great together.
GO TEAM!
public void CreateEntity(GameBlueprint blueprint)
{ if (blueprint != null) { if (blueprint.Template is GameObject prefab) { var instance = Object.Instantiate(prefab); if (instance.TryGetComponent(out GameEntity entity)) { if (entity.transform.parent.TryGetComponent(out GameEntity parent)) { _system.AddEntityDependency(parent, entity); } _system.NotifyEntityCreated(entity); } } } }Recently I was struggling with actually getting the 'roslyn source code generator' to generate things available to my other project inside Rider.
Storing this as a memo for the exact things that made this work so I have a good baseline to branch out from in the future. Might help someone.
Setup the project
- New Solution
-- Generator (class library, netstandard2.0)
-- MyConsoleApp (console app, netstandard2.0)
ManageNuGetPackages
- Microsoft.CodeAnalysis.Analyzers
- Microsoft.CodeAnalysisCSharp.Workspaces
- Microsoft.Compilers.Toolset
- NetStandard.Library 2.x.x
MyConsoleApp-project
Add a dependency to Generator, and then modify the .csproj file like this
<!-- Add this as a new ItemGroup, replacing paths and names appropriately -->
<ItemGroup>
<ProjectReference Include="..\Generator\Generator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Net.Compilers.Toolset" Version="4.3.1">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
</ItemGroup>
Generator-project
Adding launchsettings.json
Create a file at ./Properties/launchSettings.json and paste the following code inside it (I had to create the Properties-Directory inside Rider)
{
"$schema": "http://json.schemastore.org/launchsettings.json",
"profiles": {
"Generators": {
"commandName": "DebugRoslynComponent",
"targetProject": "../MyConsoleApp/MyConsoleApp.csproj"
}
} }Create the Generator-file
Create a file called HelloWorldGenerator.cs and paste this content inside itusing System.Text;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Text;
namespace Generator;
[Generator]
public class HelloWorldGenerator : ISourceGenerator
{
public void Initialize(GeneratorInitializationContext context)
{
}
public void Execute(GeneratorExecutionContext context)
{
// begin creating the source we'll inject into the users compilation
var sourceBuilder = new StringBuilder(@"
using System;
namespace HelloWorldGenerated
{
public static class HelloWorld
{
public static void SayHello()
{
Console.WriteLine(""Hello from generated code!"");
Console.WriteLine(""The following syntax trees existed in the compilation that created this program:"");
");
// using the context, get a list of syntax trees in the users compilation
var syntaxTrees = context.Compilation.SyntaxTrees;
// add the filepath of each tree to the class we're building
foreach (SyntaxTree tree in syntaxTrees)
{
sourceBuilder.AppendLine($@"Console.WriteLine(@"" - {tree.FilePath}"");");
}
// finish creating the source to inject
sourceBuilder.Append(@"
}
}
}");
// inject the created source into the users compilation
context.AddSource("helloWorldGenerator", SourceText.From(sourceBuilder.ToString(), Encoding.UTF8));
}
}
End result after doing a couple of attempts at- Reload project
- Restart Rider
- Rebuild SolutionInside the console app it should now be possible to writeHelloWorldGenerated.HelloWorld.SayHello();
And inside the 'solution view' you should be able to see the following by expanding/MyConsoleApp/Dependencies/.NetStandard2.0/Source Generators/Generator.HelloWorldGenerator