chore: update readme

CONTRIBUTING.md

@@ -0,0 +1,105 @@
+# Contributing to the OpenFeature project
+
+## Development
+
+You can contribute to this project from a Windows, macOS or Linux machine.
+
+On all platforms, the minimum requirements are:
+
+* Git client and command line tools.
+* .netstandard 2.0 or higher capable dotnet sdk (.Net Framework 4.6.2 or higher/.Net Core 3 or higher).
+
+### Linux or MacOS
+
+* Jetbrains Rider 2022.2+ or Visual Studio 2022+ for Mac or Visual Studio Code
+
+### Windows
+
+* Jetbrains Rider 2022.2+ or Visual Studio 2022+ or Visual Studio Code
+* .NET Framework 4.6.2+
+
+## Pull Request
+
+All contributions to the OpenFeature project are welcome via GitHub pull requests.
+
+To create a new PR, you will need to first fork the GitHub repository and clone upstream.
+
+```bash
+git clone https://github.com/open-feature/dotnet-sdk.git openfeature-dotnet-sdk
+```
+
+Navigate to the repository folder
+```bash
+cd openfeature-dotnet-sdk
+```
+
+Add your fork as an origin
+```bash
+git remote add fork https://github.com/YOUR_GITHUB_USERNAME/dotnet-sdk.git
+```
+
+Makes sure your development environment is all setup by building and testing
+```bash
+dotnet build
+dotnet test
+```
+
+To start working on a new feature or bugfix, create a new branch and start working on it.
+
+```bash
+git checkout -b feat/NAME_OF_FEATURE
+# Make your changes
+git commit
+git push fork feat/NAME_OF_FEATURE
+```
+
+Open a pull request against the main dotnet-sdk repository.
+
+### How to Receive Comments
+
+* If the PR is not ready for review, please mark it as
+  [`draft`](https://github.blog/2019-02-14-introducing-draft-pull-requests/).
+* Make sure all required CI checks are clear.
+* Submit small, focused PRs addressing a single concern/issue.
+* Make sure the PR title reflects the contribution.
+* Write a summary that helps understand the change.
+* Include usage examples in the summary, where applicable.
+
+### How to Get PRs Merged
+
+A PR is considered to be **ready to merge** when:
+
+* Major feedbacks are resolved.
+* It has been open for review for at least one working day. This gives people
+  reasonable time to review.
+* Trivial change (typo, cosmetic, doc, etc.) doesn't have to wait for one day.
+* Urgent fix can take exception as long as it has been actively communicated.
+
+Any Maintainer can merge the PR once it is **ready to merge**. Note, that some
+PRs may not be merged immediately if the repo is in the process of a release and
+the maintainers decided to defer the PR to the next release train.
+
+If a PR has been stuck (e.g. there are lots of debates and people couldn't agree
+on each other), the owner should try to get people aligned by:
+
+* Consolidating the perspectives and putting a summary in the PR. It is
+  recommended to add a link into the PR description, which points to a comment
+  with a summary in the PR conversation.
+* Tagging subdomain experts (by looking at the change history) in the PR asking
+  for suggestion.
+* Reaching out to more people on the [CNCF OpenFeature Slack channel](https://cloud-native.slack.com/archives/C0344AANLA1).
+* Stepping back to see if it makes sense to narrow down the scope of the PR or
+  split it up.
+* If none of the above worked and the PR has been stuck for more than 2 weeks,
+  the owner should bring it to the OpenFeatures [meeting](README.md#contributing).
+
+## Design Choices
+
+As with other OpenFeature SDKs, dotnet-sdk follows the
+[openfeature-specification](https://github.com/open-feature/spec).
+
+## Style Guide
+
+This project includes a [`.editorconfig`](./.editorconfig) file which is
+supported by all the IDEs/editor mentioned above. It works with the IDE/editor
+only and does not affect the actual build of the project.

OpenFeature.SDK.sln

@@ -14,6 +14,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "build", "build", "{72005F60
 		.github\workflows\linux-ci.yml = .github\workflows\linux-ci.yml
 		.github\workflows\release-package.yml = .github\workflows\release-package.yml
 		.github\workflows\windows-ci.yml = .github\workflows\windows-ci.yml
+		README.md = README.md
+		CONTRIBUTING.md = CONTRIBUTING.md
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{C97E9975-E10A-4817-AE2C-4DD69C3C02D4}"

README.md

@@ -17,18 +17,131 @@ The packages will aim to support all current .NET versions. Refer to the current
 | ----------- | ----------- |
 | TBA | TBA       |
 
-## Basic Usage
+## Getting Started
+
+### Basic Usage
 
 ```csharp
 using OpenFeature.SDK;
 
+// Sets the provider used by the client
 OpenFeature.Instance.SetProvider(new NoOpProvider());
+// Gets a instance of the feature flag client
 var client = OpenFeature.Instance.GetClient();
-
+// Evaluation the `my-feature` feature flag
 var isEnabled = await client.GetBooleanValue("my-feature", false);
 ```
 
-## Contributors
+### Provider
+
+To develop a provider, you need to create a new project and include the OpenFeature SDK as a dependency. This can be a new repository or included in an existing contrib repository available under the OpenFeature organization. Finally, you’ll then need to write the provider itself. In most languages, this can be accomplished by implementing the provider interface exported by the OpenFeature SDK.
+
+Example of implementing a feature flag provider
+
+```csharp
+using OpenFeature.SDK;
+using OpenFeature.SDK.Model;
+
+public class MyFeatureProvider : FeatureProvider
+{
+    public static string Name => "My Feature Provider";
+
+    public Metadata GetMetadata()
+    {
+        return new Metadata(Name);
+    }
+
+    public Task<ResolutionDetails<bool>> ResolveBooleanValue(string flagKey, bool defaultValue,
+        EvaluationContext context = null,
+        FlagEvaluationOptions config = null)
+    {
+        // code to resolve boolean details
+    }
+
+    public Task<ResolutionDetails<string>> ResolveStringValue(string flagKey, string defaultValue,
+        EvaluationContext context = null,
+        FlagEvaluationOptions config = null)
+    {
+        // code to resolve string details
+    }
+
+    public Task<ResolutionDetails<int>> ResolveIntegerValue(string flagKey, int defaultValue,
+        EvaluationContext context = null,
+        FlagEvaluationOptions config = null)
+    {
+        // code to resolve integer details
+    }
+
+    public Task<ResolutionDetails<double>> ResolveDoubleValue(string flagKey, double defaultValue,
+        EvaluationContext context = null,
+        FlagEvaluationOptions config = null)
+    {
+        // code to resolve integer details
+    }
+
+    public Task<ResolutionDetails<T>> ResolveStructureValue<T>(string flagKey, T defaultValue,
+        EvaluationContext context = null,
+        FlagEvaluationOptions config = null)
+    {
+        // code to resolve object details
+    }
+}
+```
+
+### Hook
+
+Hooks are a mechanism that allow for the addition of arbitrary behavior at well-defined points of the flag evaluation life-cycle. Use cases include validation of the resolved flag value, modifying or adding data to the evaluation context, logging, telemetry, and tracking.
+
+Example of adding a hook
+
+```csharp
+// add a hook globally, to run on all evaluations
+openFeature.AddHooks(new ExampleGlobalHook());
+
+// add a hook on this client, to run on all evaluations made by this client
+var client = OpenFeature.Instance.GetClient();
+client.AddHooks(new ExampleClientHook());
+
+// add a hook for this evaluation only
+var value = await client.GetBooleanValue("boolFlag", false, context, new FlagEvaluationOptions(new ExampleInvocationHook()));
+```
+
+Example of implementing a hook
+
+```csharp
+public class MyHook : Hook
+{
+  public Task<EvaluationContext> Before<T>(HookContext<T> context,
+      IReadOnlyDictionary<string, object> hints = null)
+  {
+    // code to run before flag evaluation
+  }
+
+  public virtual Task After<T>(HookContext<T> context, FlagEvaluationDetails<T> details,
+      IReadOnlyDictionary<string, object> hints = null)
+  {
+    // code to run after successful flag evaluation
+  }
+
+  public virtual Task Error<T>(HookContext<T> context, Exception error,
+      IReadOnlyDictionary<string, object> hints = null)
+  {
+    // code to run if there's an error during before hooks or during flag evaluation
+  }
+
+  public virtual Task Finally<T>(HookContext<T> context, IReadOnlyDictionary<string, object> hints = null)
+  {
+    // code to run after all other stages, regardless of success/failure
+  }
+}
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to the OpenFeature project.
+
+Our community meetings are held regularly and open to everyone. Check the [OpenFeature community calendar](https://calendar.google.com/calendar/u/0?cid=MHVhN2kxaGl2NWRoMThiMjd0b2FoNjM2NDRAZ3JvdXAuY2FsZW5kYXIuZ29vZ2xlLmNvbQ) for specific dates and for the Zoom meeting links.
+
 
 Thanks so much for your contributions to the OpenFeature project.
 
@@ -37,3 +150,7 @@ Thanks so much for your contributions to the OpenFeature project.
 </a>
 
 Made with [contrib.rocks](https://contrib.rocks).
+
+## License
+
+[Apache License 2.0](LICENSE)