No one is immune to the dreaded shank. Not even Tiger Woods.

Tiger Woods opens The Genesis Invitational in 72, deals with back spasms - PGA TOUR

Thursday was an up-and-down day for Tiger Woods, as he posted a 1-over 72 during the first round of the 2024 Genesis Invitational at Riviera Country Club in Pacific Palisades, California. Woods tees off for his second round at 2:54 p.

Shot-by-shot: Follow Tiger Woods' second round of the 2024 Genesis Invitational at Riviera

Patrick Cantlay should be issued with a 'huge fine' for not doing more to warn fans of his wayward shot on the 18th hole after benefitting from the ball bouncing back towards the green, according to a former European Tour star.

Genesis Invitational star called to be hit with 'huge fine' after benefitting from lucky bounce

Bankrupt crypto lender and trading desk Genesis had its plan to sell $1.6 billion worth of GBTC shares approved by a judge.

Genesis Approved to Sell $1.6 Billion Grayscale Bitcoin Trust Shares - Decrypt

Genesis owners are advised to park their vehicles "outside and away from structures" until the repair is complete.

Hyundai recalls nearly 100,000 Genesis vehicles for fire risk: Here's which cars are affected

During Thursday’s opening round of the Genesis Invitational, PGA Tour star Patrick Cantlay received some criticism for not yelling “fore” on a handful of his wayward shots on the back nine at Riviera Country Club. Among the critics was former professional golfer, Tony Johnstone.

6-time Euro Tour champ says Patrick Cantlay ‘should be nailed with a huge fine’ over Genesis incident

How to watch Tiger Woods on Friday at the 2024 Genesis Invitational, including Tiger's Friday tee time, TV coverage and streaming times.

How to watch Tiger Woods on Friday at 2024 Genesis Invitational: TV, streaming

In a stunning seven-hole collapse at Riviera, Rory McIlroy fell from 10th to 64th during the first round of the Genesis Invitational.

In stunning 7-hole nosedive, Rory McIlroy drops 54 spots at Genesis Invitational

The golfing legend admits his body is still not 100 percent.

Golf: Eventful final hole leaves Tiger Woods over par for Genesis Invitational opening round | Newshub

Round 2 action from The Genesis Invitational gets underway Friday from The Riviera Country Club. The third of eight Signature Events this season will feature a

The Genesis Invitational, Round 2: How to watch, featured groups, live scores, tee times, TV times - PGA TOUR

Genezio

genezio

Static code analysis is a great tool for spotting some kinds of error in your code, for example, not disposing of objects that implement IDisposable. Also, it helps to enforce and validate if the code written is following a defined standard, for example, using PascalCase for class names and camelCase for parameter names. In this post I'll show how to use Roslyn Analyzers with C# to enforce some standards of code quality and code style on your code, throwing errors at compile time if any rules are not being respected and not allowing the code to be pushed to protected branches of the repository. This is part two in a three-part series on setting up a uniform formatting standard in your code editor. Read part 1 . here Roslyn Analyzers is the compiler platform for .NET. Roslyn Analyzers are static code analysis tools for Roslyn. They inspect your code for style, quality, maintainability, and practices that are likely to cause bugs. They work based on predefined rules that can have their severity configured in the file. Roslyn EditorConfig .NET 5 and later have the analyzers enabled by default. To enable them in earlier versions of .NET, you can set the property to on project files that uses a or install them as a nuget package: EnableNETAnalyzers true project SDK Setting EnableNETAnalyzers on the project file <PropertyGroup>
  <EnableNETAnalyzers>true</EnableNETAnalyzers>
</PropertyGroup> Installing as a nuget package Install-Package Microsoft.CodeAnalysis.NetAnalyzers Enabling more analyzers By default, only some rules are enabled, but we can configure this with the property in the project file: AnalysisMode <PropertyGroup>
  <AnalysisMode>Recommended</AnalysisMode>
</PropertyGroup> The property values allowed are different for .NET 6 and .NET 5 SDKs. Details . AnalysisMode here How to enable .NET Analyzers in VS Code .NET Analyzers work by default in Visual Studio, but they have to be enabled in VS Code. 1 - Navigate to . File > Preferences > Settings 2 - Navigate to or search for . Extensions > C# configuration omnisharp.enableRoslynAnalyzers 3 - Check the option. Omnisharp: Enable Roslyn Analyzers 4 - Navigate to or search for . Extensions > C# configuration omnisharp.enableEditorConfigSupport 5 - Check the option. Omnisharp: Enable Editor Config Support 6 - Restart C#/Omnisharp extension or VS Code. Types of rules .NET Analyzers have many categories of rules, but here I'll list just a few to explain how they interact with Visual Studio's features. : Default Editorconfig options, like indent size and tabs or spaces; Standard formatting : Language specific indentation, whitespaces, and wrapping. For instance, use spaces before parentheses in method definitions. Code Style - .NET Formatting : C# and Visual Basic specific rules. Examples: using instead of an explicit type, prefer auto properties instead of backing fields. Code Style - .NET Language var : Rules about the naming of code elements, like enforcing PascalCase for classes' names and Async at the end of async methods' names. Code Style - Naming Conventions : Rules for code that is unreachable or unused variables, fields, etc. Code Style - Unnecessary code : Rules to improve code quality. These rules help identify code that are likely to cause bugs or security problems. Examples: Do not declare static members on generic types, and Enums should have zero value. Code Quality The table below shows in which features of Visual Studio the fixes for these types of rules are applied on. Fixes applied on 🖹 Format 🧹 Code Cleanup 💡 Code Fix Standard Formatting ✔️ ✔️ ✔️ .NET Formatting ✔️ ✔️ ✔️ .NET Language ✔️ ✔️ Naming Conventions ✔️ Unnecessary Code ❗ ✔️ Code Quality ❗ ❗ Only some rules have fixes applied. 💡 In the , I explain how to configure Visual Studio to apply this rules on Code Cleanup and how to auto execute Code Cleanup on file save. previous post of this series Enforcing rules in our code Rules are configured in the EditorConfig file (that I explained in the of this series) and their severity can be defined in three levels. Conflicts in the rules are resolved in the following order: Part 1 Specific rules Category rules All analyzers rules In the example below, Naming rules violations ( ) will be considered , because it is defined for the specific rule: IDE1006 Warning # Defines that all analyzers rules are suggestions
dotnet_analyzer_diagnostic.severity = suggestion
# Defines that all Code Style analyzers rules are errors
dotnet_analyzer_diagnostic.category-Style.severity = error
# Defines that the rule IDE1006 is a warning
dotnet_diagnostic.IDE1006.severity = warning 1. Generate an EditorConfig file from Visual Studio First, we need to create an EditorConfig file with the configuration of the rules we will use as standards. Visual Studio has a tool to help you configure the rules of your EditorConfig file, showing a snippet of code of how the rules work. code style Go to Tools > Options > Text Editor > C# > Code Style; Configure your Code Style preferences in the General, Formatting and Naming sub-menus.
⚠️ Don't bother setting the severities here; some of them are only respected by Visual Studio and are not enforced on build and other IDEs; Back in the General sub-menu, click and save it in the folder your solution file is in ( ). Generate .editoconfig file from settings .sln ⚠️ If you are not using Visual Studio, you can use a sample and change it to your preferences, like the one from . Roslyn 2. Configure all projects to use the recommended .NET Analyzers Next, we set the AnalysisMode property in all our project files. For .NET 6 SDK and later, set it to or . Recommended All <PropertyGroup>
  <AnalysisMode>Recommended</AnalysisMode>
</PropertyGroup> 3. Set severity Error for all analyzers rules In our EditorConfig, include this line to set severity to for all rules. error # Set severity = error for all analyzers
dotnet_analyzer_diagnostic.severity = error 4. Correct the errors and override the severity for rules you don't want to use If you are enabling the analyzers in an existing project, many errors will be shown. Correct them and override their severity if they don't apply for you or you won't correct them at the moment. 💡 In the , I explain how to add fixers to Visual Studio's Code Cleanup. You can customize it to fix some rules violations. previous post of this series Setting rules severity directly in EditorConfig file # Other rules ...

# Set severity = none to the rules that are not important for me
dotnet_diagnostic.IDE0075.severity = none

# Set severity = warning to the rules that need to be resolved later
dotnet_diagnostic.IDE0047.severity = warning Setting rules severity from Visual Studio's Error List For errors showing up in the Error List, you can right click on the rule and click on . The severity configuration will be added to the EditorConfig file. Set severity > Choose a severity Setting rules severity from Visual Studio's Solution Explorer From Solution Explorer, open the node below your project, then right click on the rule and click on . The severity configuration will be added to the EditorConfig file. Dependencies > Analyzers Set severity > Choose a severity 5. Enforce the rules on build Enabling the analyzers only shows the messages in our IDE. To really enforce those rules, we have to inform the compiler to fail in case of rules violations, blocking changes that are not compliant to the standard to be merged into protected branches of the repository. To do this, we need to enable the property in all our project files. EnforceCodeStyleInBuild <PropertyGroup>
  <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
</PropertyGroup> Examples of rules being enforced Rules being enforced on Visual Studio Rules being enforced on VS Code Rules being enforced on dotnet build command Creating additional naming conventions Here are some naming conventions of the C# language: Symbols Convention Example class/record/struct PascalCase PhysicalAddress interface "I"+PascalCase IWorkerQueue public members PascalCase StartEventProcessing private/internal fields "_"+camelCase _workerQueue static fields "s_"+camelCase s_workerQueue local variables *️ camelCase isValid parameters camelCase name async methods PascalCase+"Async" GetStringAsync More details . here By default, Visual Studio doesn't create naming conventions for static fields, local variables, parameters and async methods. If we want to use them, we have to manually set those rules, as shown below. *️ Not specified in the docs, but . Roslyn uses this convention Creating the naming convention for async methods dotnet_naming_rule.async_methods_should_be_pascalcase_async.severity = error
dotnet_naming_rule.async_methods_should_be_pascalcase_async.symbols = async_methods
dotnet_naming_rule.async_methods_should_be_pascalcase_async.style = pascalcase_async

dotnet_naming_symbols.async_methods.applicable_kinds = method
dotnet_naming_symbols.async_methods.applicable_accessibilities = *
dotnet_naming_symbols.async_methods.required_modifiers = async

dotnet_naming_style.pascalcase_async.required_suffix = Async
dotnet_naming_style.pascalcase_async.capitalization = pascal_case Creating the naming convention for local variables and parameters dotnet_naming_rule.locals_and_parameters_should_be_pascal_case.severity = error
dotnet_naming_rule.locals_and_parameters_should_be_pascal_case.symbols = locals_and_parameters
dotnet_naming_rule.locals_and_parameters_should_be_pascal_case.style = camel_case

dotnet_naming_symbols.locals_and_parameters.applicable_kinds = parameter, local

dotnet_naming_style.camel_case.capitalization = camel_case How to ignore the CA1707 rule (Identifiers should not contain underscores) on test projects Some conventions for naming test methods use underscore. If that is your case, you will receive a violation for the CA1707 rule. To disable the rule only on the test project, create a file named in the root of your test project with the content below. GlobalSuppressions.cs using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Naming", "CA1707:Identifiers should not contain underscores", Justification = "Not applicable for test names", Scope = "module")] Third-party analyzers There are third-party analyzers that can have additional rules that can be useful. These are some: Roslynator StyleCop Sonar Analyzer References and Links https://learn.microsoft.com/en-us/visualstudio/code-quality/install-net-analyzers?view=vs-2022 https://www.jetbrains.com/help/rider/Using_EditorConfig.html#export-code-style-settings https://marketplace.visualstudio.com/items?itemName=MadsKristensen.EditorConfig Liked this post? I post extra content in my personal blog. to see. Click here Also published . here

Spotting and Preventing Formatting Errors in Your Code 

Git is the most popular source control system with an incredible 93.87% of adoption by developers (according to ). It's a really powerful system with lots of hidden features not known by most of us developers. StackOverflow's 2022 Survey In this post, I'll show some of these features that will make your work easier when using Git. 1 - Remove remote-deleted branches on fetch Excerpt from : Git documentation Git has a default disposition of keeping data unless it’s explicitly thrown away; this extends to holding onto local references to branches on remotes that have themselves deleted those branches. If left to accumulate, these stale references might make performance worse on big and busy repos that have a lot of branch churn, and e.g. make the output of commands like git branch -a --contains <commit> needlessly verbose, as well as impacting anything else that’ll work with the complete set of known references. To remove local branches that have no remote-tracking references while fetching all branches, instead of using the parameter, use the parameter: --all --prune git fetch --prune git fetch --prune Documentation 2 - Merge/Rebase without checking out the target branch When making a merge or a rebase, it's common to see people do the following: git checkout branch-to-merge-from
git pull
git checkout my-working-branch
git merge branch-to-merge-from Git branches are just references to a commit. When we make a fetch, the remote branches are created locally with a prefix, so there is no need to check out the before merging. origin/ branch-to-merge-from ℹ️ The remote branch prefix depends on the remote name, but the default is . origin The following works without having to checkout and pull in the local branch : branch-to-merge-from git fetch --prune
git merge origin/branch-to-merge-from git Remote Branch Documentation 3 - Trigger the CI/CD pipeline with a blank commit If you are working with a CI/CD pipeline (and you should be), sometimes you need to trigger the pipeline without making changes to the code. Instead of changing files adding empty lines at the end, or creating unnecessary logs, we can create an empty commit: git commit --allow-empty -m 'Empty commit'
git push git commit --allow-empty Documentation 4 - View a file in another branch When working on a feature, we often need to check a file in another branch, for example, in the production branch (main). Some Git services offer a web interface that makes it easier to look for files in specific branches, but if you don't have this option, Git can show the file in the command line without having to switch branches, using the command followed by the branch name and the path to the file. show git show main:src/Program.cs As with other Git commands, we can pass any commit or reference, instead of the branch name: # Show the program.cs file in the previous commit
git show HEAD~1:src/Program.cs git show Documentation 5 - Checkout the previously used branch To switch back to the previously checked-out branch, just pass as the branch parameter: - git checkout develop
git checkout main
git checkout - #Checkout the develop branch 6 - Searching in Git If you want to search for a string in your repository, use the command. git grep To look for the string in all commits, provide the list of commits to using the command as shown below: git grep git rev-list --all # Search for the word "git" in all files of all commits
git rev-list --all | xargs git grep "git" git grep Documentation 7 - Showing the commit log as a graph Git can show the commit logs in the form of a graph in the command line. For this, use the parameter of the command. --graph git log ℹ️ Pass the parameter to show the commit hash and commit message in one line, and make it easier to read the graph. --oneline git log --graph --oneline Git can also show the commit history of a specific file: git log --graph --oneline systemcontext.md git log --graph Documentation Also published here. Like this post? Follow me: Feedly RSS Linkedin Twitter Mastodon

7 Ways You Can Use Git to Boost Productivity

When working with other people and multiple editors/IDEs, it is common to have different editor settings, losing consistency in formatting styles of the code. For example: Using tabs/spaces and different sizes of indentation, making your code harder to read; Using different encoding between files, causing hard to find bugs at runtime (showing invalid characters) and breaking automated tests. In this post I'll show how to maintain a standard for everyone who works in the code, no matter the editor used, and in a next post I'll show how to enforce these (and other) rules on build and in the continuous integration pipeline. Enter the EditorConfig file The EditorConfig file is used by editors and IDEs to define editor preferences for the project. Without it, IDEs and editors will use their general configuration, causing divergences in the files edited on them. Many editors and IDEs support the EditorConfig file , and others . Here are some: by default have plugins to support it Visual Studio (Built-in); JetBrains Rider (Built-in); GitHub (Built-in); VS Code (Plugin); Vim (Plugin); Emacs (Plugin); Sublime (Plugin); It has a default name of and is an INI file where sections are filename filters, for instance: .editorconfig for files; [*.cs] .cs for javascript files inside the folder and subdirectories; [scripts/**.js] scripts for the file only. [{package.json}] package.json More details here The EditorConfig can be put in any directory and be overridden by EditorConfig files in child directories, but for better visibility, they should be in the same directory as the .NET solution file. Adding an EditorConfig to your project To include an EditorConfig to your project, just create a file named in the same directory of your solution file ( ) with the content below. .editorconfig .sln # Top-most EditorConfig file.
root = true

# Section for C# files
# All rules below apply only to .cs files
[*.cs]

#### Core EditorConfig Options ####

# Indentation and spacing
indent_style = space
indent_size = 4

# New line preferences
end_of_line = crlf
insert_final_newline = false
trim_trailing_whitespace = true

# Charset preference
charset = utf-8 This file set these rules: : No editorconfig file in parent directories will be read; root : Indentation should use space; indent_style : Indentation should use 4 space characters; indent_size : Lines should end with CR+LF characters; end_of_line : Do not automatically insert empty lines at the end of the files; insert_final_newline : Empty lines should have no space characters; trim_trailing_whitespace : Files should be encoded with UTF-8 format. charset More details . here ⚠️ and change it back to CRLF on checkouts. Then, the settings can be safely set to CRLF. GIT for Windows suggests this configuration by default at installation. Details on how to configure are . GIT can change the line ends to LF on pushes to the repository end_of_line here ⚠️ , according to the Unicode standard. . UTF-8 with BOM is not required nor recommended More here ℹ️ specific to the .NET environment. In a next post, I'll show how to configure these rules. In .NET, the EditorConfig file can also be used to define analyzers rules and severities Appling the new formatting rules to code When we change the formatting rules for an existing project, the changes are not applied automatically. We need to manually trigger an auto-format. Visual Studio First, we have to include the fixer to a Code Cleanup profile. Format document 1 - Navigate to . Analyze > Code Cleanup > Configure Code Cleanup 2 - Include the fixer for the profile you wish to run on save. Format document 3 - On the menu, select . Analyze > Code Cleanup > Run Code Cleanup (Yout Profile) on Solution ⚠️ . You have to use the dotnet-format or another tool for that. Visual Studio's format document doesn't change the file encoding VS Code VS Code doesn't have a feature to format all files at once. You have to use the extension. Format Files 1 - Install the . Format Files extension 2 - Navigate to or press . View > Command Palette Ctrl+Shift+P 3 - Select the or option. Start Format Files: Workspace Start Format Files: From Glob JetBrains Rider Select or press . Code > Reformat Code Ctrl+Alt+Enter Format on save When we create an EditorConfig file, the supported editors will also use the configurations for their auto-format features. Here I show how to enable the auto-format on file save in some editors. Format on save in Visual Studio Visual Studio 2022 doesn't have a format on save feature, but it can run a Code Cleanup on save. This way we can configure a Code Cleanup profile to run a and use it on save. Format document ℹ️ For Visual Studio 2019, there is an that enables the same feature. extension 1 - Configure your Code Cleanup profile to run the fixer, as shown in the previous section of this post. Format document 2 - Navigate to . Tools > Options > Text Editor > Code Cleanup 3 - Check the option and select the Code Cleanup profile to run on save. Run Code Cleanup profile on Save Now Visual Studio will format your files on every save. Format on save in VS Code 1 - Navigate to . File > Preferences > Settings 2 - Navigate to or search for . Text Editor > Formatting editor.formatOnSave 3 - Check the option. Editor: Format On Save Format on save in JetBrains Rider 1 - Navigate to . File > Settings > Tools > Actions on Save 2 - Check the option. Reformat and Cleanup Code 3 - Select the profile. Reformat Code References and Links https://editorconfig.org/ https://devblogs.microsoft.com/visualstudio/bringing-code-cleanup-on-save-to-visual-studio-2022-17-1-preview-2/ https://learn.microsoft.com/en-us/visualstudio/ide/create-portable-custom-editor-options?view=vs-2022 https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-format Liked this post? I post extra content in my personal blog. to see. Click here Also published . here

Stories, News & Mentions about GENEZIO

Genezio’s Stories on HackerNoon

Genezio's News & Mentions