m-lamonaca/dev-notes
1
0
Fork 0
mirror of https://github.com/m-lamonaca/dev-notes.git synced 2025-04-06 10:56:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'main' into NET-6

Browse source
This commit is contained in:
Marcello 2021-09-17 23:52:42 +02:00
commit 48000eab9d
5 changed files with 298 additions and 125 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

120
CSS/CSS.md
View file

@ -5,7 +5,7 @@
### Inline CSS
```html
<tag style=”property:value”></tag>
<tag style="property:value"></tag>
```
Uses the HTML style attribute.
@ -20,14 +20,14 @@ Not recommended except in cases where choices are constrained.
selector {
property: value;
/* box and display */
/* alignement, position */
/* alignment, position */
/* margin, border, padding */
/* max/min height-width*/
/* colors */
/* font */
/* text alignement */
/* text alignment */
}
</style>
</head>
@ -42,7 +42,7 @@ Not Recommended, only use when the number of rules is small and there are constr
```html
<head>
<link rel=”stylesheet” type=”text/css” href=”style.css”>
<link rel="stylesheet" href="style.css">
</head>
```
@ -52,7 +52,7 @@ Easier to maintain, especially in larger projects.
## Selectors
Tthe selector points to the html element to style.
The selector points to the html element to style.
```css
selector {property: value; property: value}
@ -87,7 +87,7 @@ Should apply to one element on a page.
### Class Selector
Many elements can have the same class, calsses are used to group HTML elements togheter.
Many elements can have the same class, classes are used to group HTML elements together.
```css
.selector {property: value;} /* selects <tag class="selector"> */
@ -291,19 +291,19 @@ selector:pseudo-class { property: value; }
`a:hover {...}` selects a link when the mouse rolls over it (hover state).
`a:active {...}` selects the link while it's being activated (clicked or otherwise).
`selector:focus {...}` selects an element whent the user focuses on it (e.g. tab w/ keyboard). Often used on links, inputs, textareas.
`selector:focus {...}` selects an element when the user focuses on it (e.g. tab w/ keyboard). Often used on links, inputs, text-areas.
### User Interface State Pseudo-Classes
`input:enabled {...}` selects an input that is in the default state of enabled and aviable for use.
`input:disabled {...}` selects an input that has the attibute.
`input:enabled {...}` selects an input that is in the default state of enabled and available for use.
`input:disabled {...}` selects an input that has the attribute.
`input:checked {...}` selects checkboxes or radio buttons that are checked.
`input:indeterminate {...}` selects checkboxes or radio button that has neither selected nor unselected.
### Structural & Position Pseudo-Classes
`selector:first-child {...}` selects an element if it’s the first child within its parent.
`selector:last-child {...}` selects an element if it’s the last element within its parent.
`selector:first-child {...}` selects an element if it's the first child within its parent.
`selector:last-child {...}` selects an element if it's the last element within its parent.
`selector:only-child {...}` will select an element if it is the only element within a parent.
`selector:first-of-type {...}` selects the first element of its type within a parent.
@ -339,44 +339,45 @@ When used within selectors allow unique parts of the page to be stylized. Only o
```css
a::after/before {
propery: value;
property: value;
content: " (" attr(attribute_name) ")";
propery: value;
property: value;
}
```
### Fragment Pseudo-Elements
`selector::selection {...}` identifies part of the document that has been selected, or highlighted, by a user’s actions.
`selector::selection {...}` identifies part of the document that has been selected, or highlighted, by a user's actions.
`selector::-moz-selection {...}` Mozilla prefixed fragment pseudo-element has been added to ensure the best support for all browser.
## Units
### Absolute Length units
| Unit | Name | Equivalent to |
| ---- | ------------------- | -------------------- |
| cm | centimeters | 1cm = 38px = 25/64in |
| mm | Millimeters | 1mm = 1/10th of 1cm |
| Q | Quarter-millimeters | 1Q = 1/40th of 1cm |
| in | Inches | 1in = 2.54cm = 96px |
| pc | Picas | 1pc = 1/6th of 1in |
| pt | Points | 1pt = 1/72th of 1in |
| px | Pixels | 1px = 1/96th of 1in |
| Unit | Name | Equivalent to |
| ------ | ------------------- | -------------------- |
| `cm` | centimeters | 1cm = 38px = 25/64in |
| `mm` | Millimeters | 1mm = 1/10th of 1cm |
| `Q` | Quarter-millimeters | 1Q = 1/40th of 1cm |
| `in` | Inches | 1in = 2.54cm = 96px |
| `pc` | Picas | 1pc = 1/6th of 1in |
| `pt` | Points | 1pt = 1/72th of 1in |
| `px` | Pixels | 1px = 1/96th of 1in |
### Relative Length Units
| Unit | Relative to |
| ---- | ------------------------------------------------------------------- |
| rem | Font size of the root element. |
| em | Font size of the parent or the element itself |
| ex | x-height of the element's font. |
| ch | The advance measure (width) of the glyph "0" of the element's font. |
| lh | Line height of the element. |
| vw | 1% of the viewport's width. |
| vh | 1% of the viewport's height. |
| vmin | 1% of the viewport's smaller dimension. |
| vmax | 1% of the viewport's larger dimension. |
| Unit | Relative to |
| ------ | ------------------------------------------------------------------- |
| `rem` | Font size of the root element. |
| `em` | Font size of the parent or the element itself |
| `ex` | x-height of the element's font. |
| `ch` | The advance measure (width) of the glyph "0" of the element's font. |
| `lh` | Line height of the element. |
| `vw` | 1% of the viewport's width. |
| `vh` | 1% of the viewport's height. |
| `vmin` | 1% of the viewport's smaller dimension. |
| `vmax` | 1% of the viewport's larger dimension. |
| `%` | Relative to the parent element |
## Element Properties
@ -449,7 +450,7 @@ Can also accept Keywords: `left`, `center`, `right` and `top`, `center`, `bottom
**Background-attachment**
Specifies whether the background image should scroll with the page or be fixed
### Font Familty
### Font Family
The font family defines which font is used. When listing multiple fonts, always list a generic name last.
@ -516,7 +517,7 @@ selector {
```css
selector {
text-decoration: line color style thickness;
text-align: alignement;
text-align: alignment;
}
```
@ -541,7 +542,7 @@ selector {
### Width
Sets the width of a block-level element or img; does not work for inline elements (unless their display property is changed).
Accepts a veriety of length units.
Accepts a variety of length units.
```css
selector {
@ -555,7 +556,7 @@ selector {
### Height
Sets the height of a block-level element or img; does not work for inline elements (unless their display property is changed).
Accepts a veriety of length units.
Accepts a variety of length units.
```css
selector {
@ -590,33 +591,6 @@ selector {
}
```
## CSS Units
### Absolute Lengths
| Symbol | Unit |
| ------ | ---------------------------- |
| `cm` | centimeters |
| `mm` | millimeters |
| `in` | inch (1 in = 96px = 2.54 cm) |
| `px` | pixel (1 px = 1/96 of 1 in) |
| `pt` | points (1 pt = 1/72 of 1 in) |
| `pc` | picas (1 pc = 12 pt) |
### Relative Lengths
| Symbol | Unit |
| ------ | ----------------------------------------------------------------------------------------- |
| `em` | Relative to the font-size of the element (2em means 2 times the size of the current font) |
| `ex` | Relative to the x-height of the current font (rarely used) |
| `ch` | Relative to width of the "0" (zero) |
| `rem` | Relative to font-size of the root element |
| `vw` | Relative to 1% of the width of the viewport* |
| `vh` | Relative to 1% of the height of the viewport* |
| `vmin` | Relative to 1% of viewport's* smaller dimension |
| `vmax` | Relative to 1% of viewport's* larger dimension |
| `%` | Relative to the parent element |
## CSS Cascading
The browser assigns different priorities to CSS depending on the type of selector.
@ -689,7 +663,7 @@ selector {
#### Padding shortcuts
```css
selectopr {
selector {
padding: top right bottom left; /* Four values (TRBL) */
padding: top right/left bottom; /* Three values (T/TL/B) */
padding: top/bottom right/left; /* Two values (TB/RL) */
@ -728,9 +702,9 @@ selector {
Defines whether the width and height (and min/max) of an element should include padding and borders or not.
```css
selecot {
box-sizinbg: content-box; /* Border and padding are not included */
box-sizinbg: border-box; /* Include the content, padding and border */
selector {
box-sizing: content-box; /* Border and padding are not included */
box-sizing: border-box; /* Include the content, padding and border */
}
```
@ -968,7 +942,7 @@ When elements overlap, the order of overlapping can be changed with z-index:
- Without z-index, elements stack in the order that they appear in the DOM
- Elements with non-static positioning will always appear on top of elements with default static positioning
**Nesting is importan**t: if element *B* is on top of element *A*, a child of element *A* can never be higher than element *B*.
**Nesting is important**: if element *B* is on top of element *A*, a child of element *A* can never be higher than element *B*.
```css
selector {
@ -981,7 +955,7 @@ selector {
```css
selector {
display: grid;
grid-template-columns: 1fr 1fr 1fr; /* 3 equl columns */
grid-template-columns: 1fr 1fr 1fr; /* 3 equal columns */
grid-template-rows: 1fr 1fr 1fr; /* 3 equal rows */
}
```
@ -1043,7 +1017,7 @@ Risks miscommunications with clients and impacts the User Experience (UX).
3. **Use content to define the layout and design**:
Understand how content can inform design
Don't spend time creating templates you won’t use
Don't spend time creating templates you won't use
Focus on problem-solving for your users
4. **Use proto-content**:
@ -1156,7 +1130,7 @@ A media query is a logical expression: true or false; if a media query is true,
| `all` | all media type devices |
| `print` | printers |
| `screen` | computer screens, tablets, smart-phones, etc |
| `speech` | screenreaders that "reads" the page out loud |
| `speech` | screen readers that "reads" the page out loud |
```css
@media type operator (feature) {

81
DotNet/C#/Async Programming.md
View file

@ -24,7 +24,7 @@ public async Task<TResult> MethodAsync
TResult result = await resultTask;
// if the is no work to be done before awaiting
TResutl result = await obj.OtherMethodAsync();
TResult result = await obj.OtherMethodAsync();
return result;
}
@ -54,7 +54,7 @@ In combination with the `Task.Run` method, async programming is better than `Bac
### Naming Convention
By convention, methods that return commonly awaitable types (for example, `Task`, `Task<T>`, `ValueTask`, `ValueTask<T>`) should have names that end with "Async". Methods that start an asynchronous operation but do not return an awaitable type should not have names that end with "Async", but may start with "Begin", "Start", or some other verb to suggest this method does not return or throw the result of the operation.
By convention, methods that return commonly awaitable types (for example, `Task`, `Task<T>`, `ValueTask`, `ValueTask<T>`) should have names that end with *Async*. Methods that start an asynchronous operation but do not return an awaitable type should not have names that end with *Async*, but may start with "Begin", "Start", or some other verb to suggest this method does not return or throw the result of the operation.
## [Async Return Types](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/async-return-types)
@ -73,7 +73,7 @@ The `Task<TResult>.Result` property is a **blocking property**. If it's accessed
The `void` return type is used in asynchronous event handlers, which require a `void` return type. For methods other than event handlers that don't return a value, it's best to return a `Task` instead, because an async method that returns `void` can't be awaited. Any caller of such a method must continue to completion without waiting for the called async method to finish. The caller must be independent of any values or exceptions that the async method generates.
The caller of a void-returning async method *can't catch exceptions thrown from the method*, and such unhandled exceptions are likely to cause the application to fail. If a method that returns a `Task` or `Task<TResult>` throws an exception, the exception is stored in the returned task. The exception is rethrown when the task is awaited. Therefore, make sure that any async method that can produce an exception has a return type of `Task` or `Task<TResult>` and that calls to the method are awaited.
The caller of a void-returning async method *can't catch exceptions thrown from the method*, and such unhandled exceptions are likely to cause the application to fail. If a method that returns a `Task` or `Task<TResult>` throws an exception, the exception is stored in the returned task. The exception is re-thrown when the task is awaited. Therefore, make sure that any async method that can produce an exception has a return type of `Task` or `Task<TResult>` and that calls to the method are awaited.
### Generalized async return types and `ValueTask<TResult>`
@ -86,3 +86,78 @@ Because `Task` and `Task<TResult>` are **reference types**, memory allocation in
### Async streams with `IAsyncEnumerable<T>`
Starting with C# 8.0, an async method may return an async stream, represented by `IAsyncEnumerable<T>`. An async stream provides a way to enumerate items read from a stream when elements are generated in chunks with repeated asynchronous calls.
### Async Composition
```cs
public async Task DoOperationsConcurrentlyAsync()
{
Task[] tasks = new Task[3];
tasks[0] = DoOperation0Async();
tasks[1] = DoOperation1Async();
tasks[2] = DoOperation2Async();
// At this point, all three tasks are running at the same time.
// Now, we await them all.
await Task.WhenAll(tasks);
}
public async Task<int> GetFirstToRespondAsync()
{
// Call two web services; take the first response.
Task<int>[] tasks = new[] { WebService1Async(), WebService2Async() };
// Await for the first one to respond.
Task<int> firstTask = await Task.WhenAny(tasks);
// Return the result.
return await firstTask;
}
```
### Context & Avoiding Context
What exactly is the "context"?
- on a UI thread it's a UI context.
- when responding to an ASP.NET request, then it's an ASP.NET request context.
- Otherwise, it's usually a thread pool context.
```cs
private async Task DownloadFileAsync(string fileName)
{
// Use HttpClient or whatever to download the file contents.
var fileContents = await DownloadFileContentsAsync(fileName).ConfigureAwait(false);
// Note that because of the ConfigureAwait(false), we are not on the original context here.
// Instead, we're running on the thread pool.
// Write the file contents out to a disk file.
await WriteToDiskAsync(fileName, fileContents).ConfigureAwait(false);
// The second call to ConfigureAwait(false) is not *required*, but it is Good Practice.
}
// UI Example
private async void DownloadFileButton_Click(object sender, EventArgs e)
{
// Since we asynchronously wait, the UI thread is not blocked by the file download.
await DownloadFileAsync(fileNameTextBox.Text);
// Since we resume on the UI context, we can directly access UI elements.
resultTextBox.Text = "File downloaded!";
}
// ASP.NET example
protected async void MyButton_Click(object sender, EventArgs e)
{
// Since we asynchronously wait, the ASP.NET thread is not blocked by the file download.
// This allows the thread to handle other requests while we're waiting.
await DownloadFileAsync(...);
// Since we resume on the ASP.NET context, we can access the current request.
// We may actually be on another *thread*, but we have the same ASP.NET request context.
Response.Write("File downloaded!");
}
```

59
DotNet/C#/Unit Testing.md
View file

@ -1,42 +1,5 @@
# Unit Testing
## MSTest
[Microsoft Unit Testing Tutorial](https://docs.microsoft.com/en-us/visualstudio/test/walkthrough-creating-and-running-unit-tests-for-managed-code?view=vs-2019)
To test a project add a **MSTest Test Projet** to the solution.
The test runner will execute any methods marked with `[TestInitialize]` once for every test the class contains, and will do so before running the actual test method itself.
The `[TestMethod]` attribute tells the test runner which methods represent tests.
In `TestClass.cs`:
```cs
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Project.Tests
{
[TestClass]
public class TestClass
{
[TestMethod]
public void TestMethod()
{
Assert.AreEqual(expected, actual);
Assert.IsTrue(bool);
Assert.IsFalse(bool);
Assert.IsNotNull(nullable);
// assertions on collections
CollectionAssert.AreEqual(expexcted, actual),
}
}
}
```
---
[UnitTest Overloaded Methods](https://stackoverflow.com/a/5666591/8319610)
[Naming standards for unit tests](https://osherove.com/blog/2005/4/3/naming-standards-for-unit-tests.html)
@ -64,3 +27,25 @@ namespace Project.Tests
}
}
```
### Test Setup & Teardown
xUnit.net creates a new instance of the test class for every test that is run, so any code which is placed into the constructor of the test class will be run for every single test.
This makes the constructor a convenient place to put reusable context setup code.
For context cleanup, add the `IDisposable` interface to the test class, and put the cleanup code in the `Dispose()` method.
## Mocking with Moq
```cs
var mockObj = new Mock<MockedType>();
mockObj.Setup(m => m.Method(It.IsAny<InputType>())).Returns(value);
mockObj.Object; // get mock
// check that the invocation is forwarded to the mock, n times
mockObj.Verify(m => m.Method(It.IsAny<InputType>()), Times.Once());
// check that the invocation is forwarded to the mock with a specific input
mockObj.Verify(m => m.Method(input), Times.Once());
```

138
DotNet/Godot/Scripting.md Normal file
View file

@ -0,0 +1,138 @@
# Godot Scripting
## Basics
```cs
using Godot;
public class NodeName : NodeType
{
[Export] // make variable visible in inspector
Type variable = value;
// Called when the node enters the scene tree for the first time.
public override void _Ready()
{
GetNode("NodeName"); // fetch a child node in the scene
GetNode("ParentNode/ChildNode"); // fetch a child node in the scene
AddToGroup("Group"); // add a node to a group (similar to tags)
GetTree().CallGroup("Group", "Function"); // call Function on all group members
var groupMembers = GetTree().GetNodesInGroup("Group");
}
// Called every frame. 'delta' is the elapsed time since the previous frame.
public override void _Process(float delta)
{
}
}
```
### Overridable Functions
```cs
public override void _EnterTree()
{
// When the node enters the Scene Tree, it becomes active and this function is called.
// Children nodes have not entered the active scene yet.
// In general, it's better to use _ready() for most cases.
base._EnterTree();
}
public override void _Ready()
{
// This function is called after _enter_tree, but it ensures
// that all children nodes have also entered the Scene Tree,
// and became active.
base._Ready();
}
public override void _ExitTree()
{
// When the node exits the Scene Tree, this function is called.
// Children nodes have all exited the Scene Tree at this point and all became inactive.
base._ExitTree();
}
public override void _Process(float delta)
{
// This function is called every frame.
base._Process(delta);
}
public override void _PhysicsProcess(float delta)
{
// This is called every physics frame.
base._PhysicsProcess(delta);
}
```
### Creating Nodes
```cs
private Sprite _sprite;
public override void _Ready()
{
base._Ready();
_sprite = new Sprite(); // Create a new sprite
AddChild(_sprite); // Add it as a child of this node
_sprite.Free(); // Immediately removes the node from the scene and frees it.
}
```
**Note**: When a node is freed, it also frees all its child nodes.
The safest way to delete a node is by using `Node.QueueFree()`. This erases the node safely during idle.
### Instantiting Scenes
```cs
// STEP 1: load the scene
var scene = GD.Load<PackedScene>("res://scene.tscn"); // Will load when the script is instanced.
// STEP 2: instantiate the scene-node
var node = scene.Instance();
AddChild(node);
```
The advantage of this two-step process is that a packed scene may be kept loaded and ready to use so that it's possible to create as many instances as desired.
This is especially useful to quickly instance several enemies, bullets, and other entities in the active scene.
## Signals
Signals are Godot's version of the *observer* pattern. They allow a node to send out a message that other nodes can listen for and respond to.
Signals are a way to decouple game objects, which leads to better organized and more manageable code. Instead of forcing game objects to expect other objects to always be present, they can instead emit signals that all interested objects can subscribe to and respond to.
```cs
public override _Ready()
{
GetNode("Node").Connect("signal", targetNode, nameof(TargetFunction)); // connect node and signal
}
// Signal Handler
public void OnEmitterSignal() { }
```
### Custom Signals
```cs
public class Node : Node2D
{
[Signal]
public delegate void CustomSignal(Type arg, ...);
public override void _Ready()
{
EmitSignal(nameof(CustomSignal), args);
}
}
```

25
Git/git.md
View file

@ -1,4 +1,4 @@
# Git Cheatsheet
# Git
## Glossary
@ -65,7 +65,7 @@ def load(id):
# human-readable names for SHA-1 hashes (mutable)
references = map<string, string>
# bind a regerence to a hash
# bind a reference to a hash
def update_reference(name, id):
references<name> = id
@ -98,7 +98,7 @@ def load_reference(name_or_id):
`git status`: shows the status of changes as untracked, modified, or staged
`git add <filename1 filename2 ...>`: add files to the staging area
`git add -p <files>`: interacively stage chuncks of a file
`git add -p <files>`: interactively stage chunks of a file
`git blame <file>`: show who last edited which line
@ -111,7 +111,7 @@ def load_reference(name_or_id):
`git diff <commit> <filename>`: show differences in a file since a particular snapshot
`git diff <reference_1> <reference_2> <filename>`: show differences in a file between two snapshots
`git diff --cached`: show what is about to be committed
`git diff <firts-branch>...<second-branch>`: show content diff between two branches
`git diff <first-branch>...<second-branch>`: show content diff between two branches
`git bisect`: binary search history (e.g. for regressions)
@ -166,14 +166,14 @@ def load_reference(name_or_id):
Git supports two types of tags: *lightweight* and *annotated*.
A lightweight tag is very much like a branch that doesn’t change—it’s just a pointer to a specific commit.
A lightweight tag is very much like a branch that doesn't change—it's just a pointer to a specific commit.
Annotated tags, however, are stored as full objects in the Git database.
They’re checksummed;contain the tagger name, email, and date; have a tagging message; and can be signed and verifiedwith GNU Privacy Guard (GPG).
It’s generally recommended creating annotated tags so it's possible to have all this information.
They're checksummed;contain the tagger name, email, and date; have a tagging message; and can be signed and verified with GNU Privacy Guard (GPG).
It's generally recommended creating annotated tags so it's possible to have all this information.
`git tag`: list existing tags
`git tag -l|--list <pattern>`: list existing tags mathcing a wildard or pattern
`git tag -l|--list <pattern>`: list existing tags matching a wildcard or pattern
`git tag <tag> [<commit_hash>]`: create a *lightweight* tag on the commit
`git tag -a <tag> [<commit_hash> -m <message>]`: create am *annotated* tag on the commit
@ -197,10 +197,10 @@ It’s generally recommended creating annotated tags so it's possible to have al
`git branch`: show list of all existing branches (* indicates current)
`git checkout <branch-name>`: change current branch (update HEAD) and update working directory
`git branch -d <branch-name>`: delete specified branch
`git branch -m <old_name> <new_name>`: rename a branch without affecting the branch’s history
`git branch -m <old_name> <new_name>`: rename a branch without affecting the branch's history
`git merge <branch-name>`: merges into current branch
`git merge --continue`: continue previous merge after solving a merge conflinct
`git merge --continue`: continue previous merge after solving a merge conflict
`git mergetool`: use a fancy tool to help resolve merge conflicts
`git rebase`: rebase set of patches onto a new base
`git rebase -i`: interactive rebasing
@ -210,6 +210,7 @@ It’s generally recommended creating annotated tags so it's possible to have al
### Undo & [Rewriting History](https://www.themoderncoder.com/rewriting-git-history/)
`git commit --amend`: replace last commit by creating a new one (can add files or rewrite commit message)
`git commit --amend -m "amended message"`: replace last commit by creating a new one (can add files or rewrite commit message)
`git commit --amend --no-edit`: replace last commit by creating a new one (can add files or rewrite commit message)
`git reset HEAD <file>`: unstage a file
`git reset <commit>`: undo all commits after specified commit, preserving changes locally
@ -234,7 +235,7 @@ git pull # get up to date
git checkout <feature_branch>
git rebase <primary_branch> # rebase commits on master (moves branch start point on last master commit)
git chechout <primary_branch>
git checkout <primary_branch>
git rebase <feature_branch> # moves commits from the branch on top of master
```
@ -255,7 +256,7 @@ git pull # clone branch
```ps1
git fetch upstream # Fetch the branches and their respective commits from the upstream repository
git checkout main # chechout fork's main primary branch
git checkout main # checkout fork's main primary branch
git merge upstream/main # Merge the changes from the upstream default branch into the local default branch